diff --git a/holoscape.js b/holoscape.js
index 92d57c5..18a6b69 100644
--- a/holoscape.js
+++ b/holoscape.js
@@ -34,6 +34,7 @@ class Holoscape {
     uiConfigWindow;
     debuggerWindow;
     installBundleView;
+    installFromFileWindow;
 
     activeView;
 
@@ -356,6 +357,33 @@ class Holoscape {
       this.installBundleView = view
     }
 
+    createInstallFromFileView() {
+      let window = new BrowserWindow({
+        width:1200,
+        height:800,
+        webPreferences: {
+          nodeIntegration: true
+        },
+        show: true,
+        icon: systemTrayIconFull(),
+      })
+      window.webContents.loadURL(path.join('file://', __dirname, 'views/legacy_install_bundle_view.html'))
+
+      let holoscape = this
+      window.on('close', (event) => {
+        holoscape.installFromFileWindow = undefined
+      })
+
+      this.installFromFileWindow = window
+    }
+
+    showInstallFromFileWindow() {
+      if(!this.installFromFileWindow) {
+        this.createInstallFromFileView()
+      }
+      this.installFromFileWindow.show()
+    }
+
     showInstallBundleView() {
       this.showView(this.installBundleView)
     }
@@ -395,6 +423,8 @@ class Holoscape {
         { label: 'Settings-'+conductor.persona(), type: 'submenu', submenu: settingsMenu },
         { label: 'Conductor Run-Time', type: 'submenu', submenu: conductorMenu },
         { type: 'separator' },
+        { label: 'Install hApp from file...', click:()=>this.showInstallFromFileWindow() },
+        { type: 'separator' },
         { label: 'Quit', click: ()=> this.quit() }
       ])
       mb.tray.setToolTip('HoloScape')
diff --git a/views/legacy_install_bundle_view.html b/views/legacy_install_bundle_view.html
new file mode 100644
index 0000000..63d647c
--- /dev/null
+++ b/views/legacy_install_bundle_view.html
@@ -0,0 +1,687 @@
+<html>
+  <head>
+    <title>Holoscape - Install hApp</title>
+    <script>window.$ = window.jQuery = require('jquery');</script>
+    <script>const Vue = require('vue/dist/vue.common');</script>
+    <script>require('popper.js');</script>
+    <script>require('bootstrap');</script>
+    <link rel="stylesheet" href="../node_modules/bootstrap/dist/css/bootstrap.min.css">
+    <link rel="stylesheet" href="common.css">
+    <style>
+      .error {
+        color: red;
+      }
+      .info {
+        color: blue;
+      }
+      .modal-spinner {
+        margin: 20px;
+      }
+      .actions {
+        max-height:420px;
+        overflow:auto;
+        background:#bbb;
+      }
+      .name {
+          font-weight: bold;
+      }
+      .screenshot {
+          max-width: 400px;
+      }
+      .hidden {
+          display: none;
+      }
+      .happItem {
+          cursor: pointer;
+          float: left;
+      }
+      .install-button {
+        font-size: 24px;
+        margin: 25px 0 60px 0;
+      }
+      .card {
+          margin: 20px 10px 10px 0;
+      }
+      .card-text {
+          color: dimgrey;
+      }
+      .properties-col {
+          max-width: 300px;
+          overflow-wrap: break-word;
+      }
+    </style>
+  </head>
+  <body>
+
+    <div id="app" class="container">
+      <h1> Holoscape - Install hApp</h1>
+
+      <ul class="list-group">
+      <li class="list-group-item">
+          <h3>Please select a bundle file to install</h3>
+                <div class="input-group">
+                    <div class="input-group-prepend">
+                        <span class="input-group-text" id="inputGroupFileAddon01">Bundle file</span>
+                    </div>
+                    <div class="custom-file">
+                        <input type="file" class="custom-file-input" id="bundle-file"
+                            aria-describedby="inputGroupFileAddon01" ref="bundleFile" @change="loadBundle">
+                        <label class="custom-file-label" for="inputGroupFile01">Choose file</label>
+                    </div>
+                </div>
+                <div v-if="fileError" class="alert alert-danger">{{ fileError }}</div>
+      </li>
+      <li v-if="bundle" class="list-group-item">
+          <h3>DNAs in this bundle</h3>
+          <table class="table">
+                <thead class="thead-light">
+                    <tr>
+                        <th scope="col">Name</th>
+                        <th scope="col">DNA Hash</th>
+                        <th scope="col">DNA Properties</th>
+                        <!--<th scope="col">URI</th>-->
+                        <th scope="col">file status</th>
+                        <th scope="col">installation status</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr v-for="instance in bundle.instances">
+                        <td class="name">{{ instance.name }}</td>
+                        <td>{{ instance.dna_hash }}<br><small v-if="instance.interpolatedDnaHash">->{{instance.interpolatedDnaHash}}</small></td>
+                        <td class="properties-col"><span v-for="(property, name, index) in instance.dna_properties">{{name}}={{property}}</span></td>
+                        <!--<td>{{ instance.uri }}</td>-->
+                        <td>
+                            <div class="badge badge-warning" v-if="instance.downloadStatus == 'pending'">
+                                Downloading
+                                <div class="spinner-border" role="status">
+                                        <span class="sr-only">Loading...</span>
+                                </div>
+                            </div>
+                            <div class="alert alert-danger" v-if="instance.error">{{instance.error}}</div>
+                            <div class="badge badge-success" v-if="instance.downloadStatus == 'done'">Ready</div>
+                            <div class="badge badge-danger" v-if="instance.fileError">
+                                <div v-if="instance.fileError.hash">
+                                    <span>{{instance.fileError.message}}</span>
+                                    <br>
+                                    <span>{{instance.fileError.hash}}</span>
+                                </div>
+                                <div v-if="!instance.fileError.hash">
+                                    {{instance.fileError}}
+                                </div>
+                            </div>
+                        </td>
+                        <!-- <td v-if="instanceStatus[instance.id] == 'installed'">
+                            <span class="badge badge-success">Already installed</span>
+                        </td>
+                        <td v-if="instanceStatus[instance.id] != 'installed'">
+                            -->
+                        <td>
+                            <span class="badge badge-danger" v-if="instance.downloadStatus=='error'">Can't install</span>
+                            <span class="badge badge-info"
+                                v-if="!instance.installedInstanceId && (instance.downloadStatus=='pending' || (instance.downloadStatus=='done' && instance.installStatus==undefined))">
+                                To be installed...
+                            </span>
+                            <span class="badge badge-dark" v-if="instance.installStatus=='installing'">Installing...</span>
+                            <div class="spinner-border" role="status" v-if="instance.installStatus == 'installing'">
+                                <span class="sr-only">Installing...</span>
+                            </div>
+                            <span class="badge badge-success" v-if="instance.installStatus=='installed'">Installed!</span>
+                            <span class="badge badge-light" v-if="instance.installedInstanceId">Already installed</span>
+                        </td>
+                </tbody>
+          </table>
+      </li>
+      <li v-if="bundle" class="list-group-item">
+            <h3>Bridges to setup</h3>
+            <table class="table">
+                  <thead class="thead-light">
+                      <tr>
+                          <th scope="col">From (caller)</th>
+                          <th scope="col">Handle</th>
+                          <th scope="col">To (callee)</th>
+                          <th scope="col">status</th>
+                      </tr>
+                  </thead>
+                  <tbody>
+                      <tr v-for="(bridge, index) in bundle.bridges">
+                          <td>{{ instanceById(bridge.caller_id).name }}</td>
+                          <td>{{ bridge.handle }}</td>
+                          <td>{{ instanceById(bridge.callee_id).name }}</td>
+                          <!--<td v-if="bridgeStatus[index] == 'installed'">
+                              <span class="badge badge-success">Already installed</span>
+                          </td>
+                          <td v-if="bridgeStatus[index] != 'installed'">-->
+                          <td>
+                            <span class="badge badge-info" v-if="bridge.installStatus==undefined && !bridge.alreadyInstalled">To be installed...</span>
+                            <span class="badge badge-dark" v-if="bridge.installStatus=='installing'">Installing...</span>
+                            <div class="spinner-border" role="status" v-if="bridge.installStatus == 'installing'">
+                                <span class="sr-only">Installing...</span>
+                            </div>
+                            <span class="badge badge-success" v-if="bridge.installStatus=='installed'">Installed!</span>
+                            <span class="badge badge-light" v-if="bridge.alreadyInstalled">Already installed</span>
+                          </td>
+                      </tr>
+                  </tbody>
+            </table>
+        </li>
+        <li v-if="bundle" class="list-group-item">
+                <h3>UIs to install</h3>
+
+                <table class="table">
+                        <thead class="thead-light">
+                            <tr>
+                                <th scope="col">Name</th>
+                                <th scope="col">Instance references</th>
+                                <!--<th scope="col">URI</th>-->
+                                <th scope="col">file status</th>
+                                <th scope="col">installation status</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr v-for="ui in bundle.UIs">
+                                <td class="name">{{ ui.name }}</td>
+                                <td>
+                                    <ul>
+                                        <li v-for="ref in ui.instance_references">
+                                            {{ instanceById(ref.instance_id).name }}
+                                        </li>
+                                    </ul>
+                                </td>
+                                <!--<td>{{ ui.uri }}</td>-->
+                                <td>
+
+                                    <div class="badge badge-warning" v-if="ui.downloadStatus == 'pending'">
+                                        Downloading
+                                        <div class="spinner-border" role="status">
+                                                <span class="sr-only">Loading...</span>
+                                            </div>
+                                    </div>
+                                    <div class="alert alert-danger" v-if="ui.error">{{ui.error}}</div>
+                                    <div class="badge badge-success" v-if="ui.downloadStatus == 'done'">Ready</div>
+                                </td>
+
+                                <td>
+                                    <span class="badge badge-danger" v-if="ui.downloadStatus=='error'">Can't install</span>
+                                    <span class="badge badge-info"
+                                        v-if="!ui.alreadyInstalled && (ui.downloadStatus=='pending' || (ui.downloadStatus=='done' && ui.installStatus==undefined))">
+                                        To be installed...
+                                    </span>
+                                    <span class="badge badge-dark" v-if="ui.installStatus=='installing'">Installing...</span>
+                                    <div class="spinner-border" role="status" v-if="ui.installStatus == 'installing'">
+                                        <span class="sr-only">Installing...</span>
+                                    </div>
+                                    <span class="badge badge-success" v-if="ui.installStatus=='installed'">Installed!</span>
+                                    <span class="badge badge-light" v-if="ui.alreadyInstalled">Already installed</span>
+                                </td>
+                            </tr>
+                        </tbody>
+                  </table>
+
+                <!--
+                <ul>
+                    <li v-for="ui in bundle.UIs">
+                        <h4>{{ ui.name }}</h4>
+                        <span>Needs access to the following instances</span>
+
+
+                        <div v-if="ui.ui_references && ui.ui_references.length > 0">
+                            <span>Needs access to the following UIs</span>
+                            <ul>
+                                <li v-for="ref in ui.ui_references">
+                                    {{ ref.ui_id }}
+                                </li>
+                            </ul>
+                        </div>
+                    </li>
+                </ul>-->
+            </li>
+      </ul>
+      <div class="list-group-item">
+        <h3>Install with admin interface?</h3>
+        <div class="input-group">
+          <input type="checkbox" id="admin-checkbox" v-model="installAsAdmin">
+        </div>
+        <h3>Select storage implementation:</h3>
+        <div class="input-group">
+           <select id="storage-impl" v-model="storageImpl">
+            <option v-for="storage in storageOpts" v-bind:value="storage">
+                {{storage}}
+            </option>
+          </select> 
+        </div>
+      <div>
+      <div class="container" v-if="bundle">
+            <div class="row justify-content-center" v-if="success">
+                <div class="col-7">
+                    <h2 class="alert alert-success">Bundle successfully installed!</h2>
+                </div>
+            </div>
+            <div class="row justify-content-end">
+                <div class="col-7">
+                    <button type="button" class="btn btn-success install-button" v-on:click="install" :disabled="!canInstall">Install</button>
+                </div>
+            </div>
+      </div>
+    </div>
+
+    <script>
+        const { ipcRenderer, shell } = require('electron')
+        const toml = require('toml')
+        const fs = require('fs')
+        const getUri = require('get-uri')
+        const temp = require('temp')
+        const extract = require('extract-zip')
+        const getPort = require('get-port');
+        const path = require('path')
+        const cli = require('../cli')
+        const request = require('request')
+        const remote = require('electron').remote
+        const happUiController = remote.getGlobal('holoscape').happUiController
+        const call = remote.getGlobal('conductor_call')
+
+        const interpolateProperties = (properties, variables) => {
+            console.log(`Interpolating DNA hash with properties: ${JSON.stringify(properties)}`)
+            let {agent_id} = variables
+            properties = instance.dna_properties
+            for(let name in properties) {
+                properties[name] = properties[name].replace("${AGENT_ID}", agent_id)
+            }
+            return properties
+        }
+
+        const interpolateDnaHash = (instance, variables) => {
+            instance.dna_properties = (instance.dna_properties, variables)
+            let {hash, error} = cli.hash(instance.tempPath, instance.dna_properties)
+            Vue.set(instance, 'interpolatedDnaHash', hash)
+            return {hash, error}
+        }
+
+        var app = new Vue({
+            el: '#app',
+            data: {
+                tab: 'happ-store',
+                canInstall: false,
+                installAsAdmin: false,
+                storageOpts: ['lmdb', 'file', 'pickle', 'memory'],
+                storageImpl: 'lmdb',
+                file: undefined,
+                fileError: undefined,
+                bundle: undefined,
+                canInstall: false,
+                success: false,
+                installed_agents: [],
+                installed_instances: [],
+                installed_dnas: [],
+                installed_bridges: [],
+                used_ports: [],
+                happ_index: [],
+                selected_happ: undefined,
+            },
+            methods: {
+                async loadBundle() {
+                if(this.$refs.bundleFile.files.length > 0) {
+                    app.file = this.$refs.bundleFile.files[0]
+                    const contents = fs.readFileSync(app.file.path)
+                    app.fileError = undefined
+                    app.bundle = undefined
+                    app.success = false
+                    try{
+                        app.bundle = toml.parse(contents)
+                        this.processBundle()
+                    }catch(e){
+                        app.fileError = e
+                    }
+
+                }
+                },
+                installedInstanceId(instance) {
+                console.log("Checking if instance is installed: ", instance)
+                let installed_dna = undefined
+
+                if(instance.dna_properties) {
+                    // If the bundle wants to have specific DNA properties set,
+                    // we have to interpolate the resulting DNA hash...
+                    // But since we have variables that can be used for property value interpolation
+                    // (currently only the agent id, but more stuff like DeepKey root key id in the future)
+                    // we have to try all combinations of agent ids and dnas to see if we have the specified
+                    // installed installed already:
+                    console.log(`Checking combinations with all agents: ${JSON.stringify(this.installed_agents)}`)
+                    for(agent of this.installed_agents) {
+                        console.log(`Checking combinations with agent: ${agent}`)
+                        let dna_hash = instance.dna_hash
+                        if(instance.dna_properties) {
+                            console.log(`Interpolating hash for instance ${instance.id} with agent ${agent.public_address}`)
+                            let {hash, error} = interpolateDnaHash(instance, {agent_id: agent.public_address})
+                            if(error) {
+                                Vue.set(instance, 'downloadStatus', 'fileError')
+                                Vue.set(instance, 'fileError', error)
+                            }
+                            console.log(`Hash: ${hash}`)
+                            dna_hash = hash
+                        }
+                        installed_dna = this.installed_dnas.find((dna)=>{return dna.hash==dna_hash})
+                        if(installed_dna) break
+                    }
+                } else {
+                    let dna_hash = instance.dna_hash
+                    installed_dna = this.installed_dnas.find((dna)=>{return dna.hash==dna_hash})
+                }
+
+                if(!installed_dna) return
+                console.log("Found DNA:", installed_dna)
+                let installed_instance = this.installed_instances.find((i)=>{return i.dna==installed_dna.id})
+                console.log("Found instance:", installed_instance)
+                return installed_instance.id
+                },
+                async processBundle() {
+                this.installed_agents = await call('admin/agent/list')()
+                this.installed_instances = await call('admin/instance/list')()
+                this.installed_dnas = await call('admin/dna/list')()
+                this.installed_bridges = await call('admin/bridge/list')()
+
+                    app.bundle.instances && app.bundle.instances.map((instance) => {
+                    console.log("Processing instance:", instance)
+                    // Here we are checking if we have an instance with the same DNA installed already.
+                    // If so, we don't install it again but use the already installed instance ID.
+                    // BUT: this first check only happens with the bundle doesn't set a property, because
+                    // setting a property would change the hash anyways. In that case we will have to download the
+                    // DNA first and then calculate the hash with property and check again if we have a DNA with that
+                    // hash already.
+                    // That happens further down...
+                    let installed_instance_id
+                    if(!instance.dna_properties) {
+                        installed_instance_id = this.installedInstanceId(instance)
+                    }
+
+                    if(installed_instance_id) {
+                        Vue.set(instance, 'installedInstanceId', installed_instance_id)
+                        this.checkInstallReady()
+                    } else {
+                        instance.tempPath = temp.path()
+                        console.log("Temp path for DNA file:", instance.tempPath)
+                        Vue.set(instance, 'downloadStatus', 'pending')
+                        let fileStream = fs.createWriteStream(instance.tempPath)
+                        console.log("Trying to get URI:", instance.uri)
+                        let uri = instance.uri
+                        if(uri.startsWith("file:./")) {
+                            const bundlePath = this.$refs.bundleFile.files[0].path
+                            let parts = uri.split('/')
+                            parts[0] = `file://${path.dirname(bundlePath)}`
+                            uri = parts.join('/')
+                        }
+                        getUri(uri, (err, rs) => {
+                            if(err) {
+                                Vue.set(instance, 'error', err.message)
+                                Vue.set(instance, 'downloadStatus', 'error')
+                                return
+                            }
+                            rs.pipe(fileStream)
+                            rs.on('end', () => {
+                                fileStream.end()
+                                let {hash, error} = cli.hash(instance.tempPath)
+                                console.log(`FOR INSTANCE ${instance.name}, got: hash = ${hash}, error = ${error}`)
+                                if(error) {
+                                    Vue.set(instance, 'downloadStatus', 'fileError')
+                                    Vue.set(instance, 'fileError', error)
+                                } else if(hash != instance.dna_hash) {
+                                    Vue.set(instance, 'downloadStatus', 'fileError')
+                                    Vue.set(instance, 'fileError', {message: 'Hash of found file is different:', hash})
+                                } else {
+                                    Vue.set(instance, 'downloadStatus', 'done')
+                                }
+
+                                // Ok, here we do the checking for already installed instances in the case of unique properties
+                                // as mentioned above:
+                                if(instance.dna_properties) {
+                                    let installed_instance_id = this.installedInstanceId(instance)
+                                    if(installed_instance_id) {
+                                        Vue.set(instance, 'installedInstanceId', installed_instance_id)
+                                    }
+                                }
+                                this.checkInstallReady()
+                            })
+                        })
+                    }
+                    })
+
+                    app.bundle.bridges && app.bundle.bridges.map((bridge) => {
+                    let caller_id = bundleInstanceIdToRealId(bridge.caller_id)
+                    let callee_id = bundleInstanceIdToRealId(bridge.callee_id)
+                    let handle = bridge.handle
+                    console.log("Checking if bridge is already there:", {caller_id, callee_id, handle})
+                    if(app.installed_bridges.find((b)=>{
+                        return b.caller_id == caller_id
+                            && b.callee_id == callee_id
+                            && b.handle == handle
+                    })) {
+                        console.log("Found bridge")
+                        Vue.set(bridge, 'alreadyInstalled', true)
+                    } else {
+                        console.log("Bridge not found")
+                    }
+                    })
+
+                    let installedUIs = happUiController.getInstalledUIs()
+
+                    app.bundle.UIs && app.bundle.UIs.map((ui) => {
+                    console.log("Processing UI:", ui)
+                    if(ui.name in installedUIs) {
+                        Vue.set(ui, 'alreadyInstalled', true)
+                        this.checkInstallReady()
+                    } else {
+                        ui.tempPath = temp.path()
+                        console.log("Temp path for UI file:", ui.tempPath)
+                        Vue.set(ui, 'downloadStatus', 'pending')
+                        let fileStream = fs.createWriteStream(ui.tempPath)
+                        let uri = ui.uri
+                        if(uri.startsWith("file:./")) {
+                            const bundlePath = this.$refs.bundleFile.files[0].path
+                            let parts = uri.split('/')
+                            parts[0] = `file://${path.dirname(bundlePath)}`
+                            uri = parts.join('/')
+                        }
+                        console.log("Trying to get URI:", uri)
+                        getUri(uri, (err, rs) => {
+                            if(err) {
+                                Vue.set(ui, 'error', err.message)
+                                Vue.set(ui, 'downloadStatus', 'error')
+                                return
+                            }
+                            rs.pipe(fileStream)
+                            rs.on('end', () => {
+                                fileStream.end()
+                                Vue.set(ui, 'downloadStatus', 'done')
+                                this.checkInstallReady()
+                            })
+                        })
+                    }
+                    })
+                },
+                instanceById(instanceId) {
+                return app.bundle.instances.find((instance) => instance.id == instanceId)
+                },
+                checkInstallReady() {
+                console.log('checkInstallReady')
+                let all_instances_ok = app.bundle.instances.reduce((acc, instance) => {
+                    let instanceReady = instance.downloadStatus == 'done' || instance.installedInstanceId
+                    return  instanceReady && acc
+                }, true)
+                let all_uis_ok = app.bundle.UIs.reduce((acc, ui) => {
+                    let uiReady = ui.downloadStatus == 'done' || ui.alreadyInstalled
+                    return uiReady && acc
+                }, true)
+                console.log('instances ok', all_instances_ok)
+                console.log('UIs ok', all_uis_ok)
+                app.canInstall = all_instances_ok && all_uis_ok
+                },
+                async install() {
+                for(instance of app.bundle.instances) {
+                    if(instance.installedInstanceId) continue
+                    Vue.set(instance, 'installStatus', 'installing')
+                    await installInstance(instance)
+                    Vue.set(instance, 'installStatus', 'installed')
+                }
+
+                for(bridge of app.bundle.bridges) {
+                    if(bridge.alreadyInstalled) continue
+                    Vue.set(bridge, 'installStatus', 'installing')
+                    await addBridge(bridge)
+                    Vue.set(bridge, 'installStatus', 'installed')
+                }
+
+                for(ui of app.bundle.UIs) {
+                    if(ui.alreadyInstalled) continue
+                    Vue.set(ui, 'installStatus', 'installing')
+                    await installUi(ui)
+                    Vue.set(ui, 'installStatus', 'installed')
+                }
+
+                app.canInstall = false,
+                app.file = undefined,
+                app.fileError = undefined,
+                app.bundle = undefined,
+                app.canInstall = false
+                app.success = true
+                },
+                getHappIndex() {
+                request('https://raw.githubusercontent.com/holochain/happ-index/master/index.json', { json: true }, (err, res, body) => {
+                    if (err) { return console.log(err); }
+                    app.happ_index = body
+                });
+                },
+                async showContentsFromHappIndex(happMeta) {
+                    app.selected_happ = happMeta
+                    let {directory} = happMeta
+                    let bundleUrl = `https://raw.githubusercontent.com/holochain/happ-index/master/happ-resources/${directory}/bundle.toml`
+                    this.installed_instances = await call('admin/instance/list')()
+                    this.installed_dnas = await call('admin/dna/list')()
+                    this.installed_bridges = await call('admin/bridge/list')()
+                    request(bundleUrl, { json: true }, (err, res, body) => {
+                    if (err) { return console.log(err); }
+                    app.bundle = toml.parse(body)
+                    this.processBundle()
+                });
+                },
+                deselect() {
+                    app.bundle = undefined
+                    app.selected_happ = undefined
+                },
+                openExternal(url) {
+                    shell.openExternal(url)
+                }
+            }
+        })
+
+        const installInstance = async (instance) => {
+            console.log('Begin installInstance:', instance.name)
+            const agent_id = `${instance.name}-agent`
+            console.log('Adding agent', agent_id)
+            await call('admin/agent/add')({id: agent_id, name: agent_id})
+            console.log('Agent added')
+            let installed_agents = await call('admin/agent/list')()
+            let agent_address = undefined
+            for(let agent of installed_agents) {
+                if(agent.id == agent_id) {
+                    agent_address = agent.public_address
+                }
+            }
+
+            const dna_id = `${instance.name}-dna`
+            const path = instance.tempPath
+            console.log('Installing DNA', dna_id)
+            let properties = undefined
+            console.log('PROPERTIES:', instance.dna_properties)
+            if(instance.dna_properties) {
+                let variables = {agent_id: agent_address}
+                properties = interpolateProperties(instance.dna_properties, variables)
+                interpolateDnaHash(instance, variables)
+            }
+            console.log('PROPERTIES interpolated:', instance.dna_properties)
+            await call('admin/dna/install_from_file')({id: dna_id, name: instance.name, path, copy: true, properties})
+            console.log('DNA installed')
+
+            const id = `${instance.name}`
+            console.log('Adding instance', id)
+            const storage = app.storageImpl
+            let instance_add_args = {id,dna_id,agent_id,storage}
+            console.log("Adding instance with ", JSON.stringify(instance_add_args))
+            await call('admin/instance/add')(instance_add_args)
+            console.log('Instance added')
+
+            console.log('Starting instance ', id)
+            await call('admin/instance/start')({id})
+            console.log('Instance started')
+        }
+
+        const bundleInstanceIdToRealId = (id) => {
+            // If the specified instance was installed before we have to make sure that use that id.
+            // Otherwise the ID we've setup when installing a new instance is the name:
+            let bundleInstance = app.bundle.instances.find((instance)=>instance.id==id)
+            return bundleInstance.installedInstanceId ? bundleInstance.installedInstanceId : bundleInstance.name
+        }
+
+        window.bundleInstanceIdToRealId = bundleInstanceIdToRealId
+
+        const addBridge = async (bridge) => {
+            console.log('Adding bridge:', bridge)
+            let {handle, caller_id, callee_id} = bridge
+            caller_id = bundleInstanceIdToRealId(caller_id)
+            callee_id = bundleInstanceIdToRealId(callee_id)
+            await call('admin/bridge/add')({handle, caller_id, callee_id})
+            console.log('Bridge added')
+        }
+
+        const nextMinPort = () => {
+            if(app.used_ports.length > 0) {
+                app.used_ports.sort()
+                return app.used_ports[app.used_ports.length -1] + 1
+            } else {
+                return 10000
+            }
+        }
+
+        const installUi = async (ui) => {
+            console.log(JSON.stringify(ui))
+            let extractedPath = temp.path()
+            console.log(`Extracting ${ui.name} to ${extractedPath}`)
+            await new Promise((resolve, reject)=>{
+                extract(ui.tempPath, {dir: extractedPath}, (err)=>{
+                    if(err) reject(err)
+                    else resolve()
+                })
+            })
+            console.log(`Extraction done. Installing UI...`)
+            await happUiController.installUIFromPath(extractedPath, ui.name)
+            console.log(`Done`)
+
+            console.log(`Creating interface for ${ui.name}`)
+            let id = `${ui.name}-interface`
+            let type = 'websocket'
+            let admin = app.installAsAdmin
+            let port = await getPort({port: getPort.makeRange(nextMinPort(), 31000)})
+            app.used_ports.push(port)
+            await call('admin/interface/add')({id,admin,type,port})
+
+            for(ref of ui.instance_references) {
+                console.log(`Applying UI -> instance reference: ${JSON.stringify(ref)}`)
+                let instance_id = bundleInstanceIdToRealId(ref.instance_id)
+                let interface_id = id
+                let alias = ref.ui_handle
+                console.log(`Adding instance '${instance_id}' to interface '${interface_id}'`)
+                await call('admin/interface/add_instance')({interface_id, instance_id, alias})
+            }
+
+            console.log(`Setting UI '${ui.name}' to use interface '${id}'`)
+            await happUiController.setUiInterface(ui.name, id)
+            console.log(`Completed install of '${ui.name}'`)
+        }
+
+        window.app = app
+        app.getHappIndex()
+    </script>
+
+
+
+
+  </body>
+</html>
