@flowfuse/driver-localfs 1.14.0

package/.eslintrc

@@ -0,0 +1,19 @@
+{
+    "root": true,
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true,
+        "mocha": true
+    },
+    "extends": [
+        "standard"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 12
+    },
+    "rules": {
+        "indent": ["error", 4],
+        "object-shorthand": ["error"]
+    }
+}

package/.github/workflows/project-automation.yml

@@ -0,0 +1,10 @@
+name: Project automations
+on:
+  issues:
+    types:
+      - opened
+jobs:
+  add_to_product_board:
+    uses: flowfuse/.github/.github/workflows/project-automation.yml@main
+    secrets:
+      token: ${{ secrets.PROJECT_ACCESS_TOKEN }}

package/.github/workflows/publish.yml

@@ -0,0 +1,58 @@
+name: Build and push package
+on:
+  workflow_dispatch:
+    inputs:
+      nr_launcher_release_name:
+        description: 'flowfuse-nr-launcher package version'
+        required: false
+        default: 'nightly'
+      nr_launcher_ref:
+        description: 'flowfuse-nr-launcher package ref'
+        required: false
+  pull_request:
+    branches: 
+      - main
+  push:
+    branches:
+      - main
+
+
+jobs:
+  build:
+    uses: 'flowfuse/github-actions-workflows/.github/workflows/build_node_package.yml@v0.1.0'
+
+  publish:
+    needs: build
+    if: |
+      ( github.event_name == 'push' && github.ref == 'refs/heads/main' ) ||
+      ( github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main' )
+    uses: 'flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml@v0.1.0'
+    with:
+      package_name: driver-localfs
+      publish_package: true
+      package_dependencies: |
+        @flowfuse/nr-launcher
+    secrets:
+      npm_registry_token: ${{ secrets.NPM_PUBLISH_TOKEN }}
+
+  dispatch:
+    name: Dispatch flowfuse package build
+    runs-on: ubuntu-latest
+    needs: publish
+    steps:
+      - name: Generate a token
+        id: generate_token
+        uses: tibdex/github-app-token@v1
+        with:
+          app_id: ${{ secrets.GH_BOT_APP_ID }}
+          private_key: ${{ secrets.GH_BOT_APP_KEY }}
+
+      - name: Trigger flowfuse package build
+        uses: benc-uk/workflow-dispatch@v1
+        with:
+          workflow: publish.yml
+          repo: flowfuse/flowfuse
+          ref: main
+          token: ${{ steps.generate_token.outputs.token }}
+          inputs: '{"localfs_ref": "${{ github.ref }}", "localfs_release_name": "${{ needs.package.outputs.release_name }}"}'
+          

package/.github/workflows/release-publish.yml

@@ -0,0 +1,18 @@
+name: Release Published
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 16
+      - run: npm ci --omit=dev
+      - uses: JS-DevTools/npm-publish@v1
+        with:
+          token: ${{ secrets.NPM_PUBLISH_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,125 @@
+#### 1.14.0: Release
+
+ - Update nr-launcher reference to new flowfuse scoped module (#103) @knolleary
+
+#### 1.13.3: Release
+
+ - Bump to v1.13.3 release @hardillb
+
+#### 1.13.0: Release
+
+ - Pin reusable workflows to v0.1.0 (#100) @ppawlowski
+ - Update ff references in package.json (#99) @knolleary
+ - Change repo references in workflows after github org rename (#97) @ppawlowski
+
+#### 1.12.0: Release
+
+ - Publish nightly package to npmjs (#96) @ppawlowski
+
+#### 1.11.1: Release
+
+ - Pin reusable workflow to commit SHA (#93) @ppawlowski
+ - Disable scheduled package build (#92) @ppawlowski
+ - Update to @flowforge/nr-launcher@1.11.1
+
+#### 1.11.0: Release
+
+ - Enable flowforge package build dispatcher after package publish (#90) @ppawlowski
+ - Bump word-wrap from 1.2.3 to 1.2.5 (#89) @app/dependabot
+ - FIX: Allow publish only when changes are pushed to `main` branch (#88) @ppawlowski
+ - Introduce publish pipeline (#85) @ppawlowski
+
+#### 1.10.0: Release
+
+
+#### 1.9.2: Release
+
+ - Update to @flowforge/nr-launcher@01.9.2
+
+#### 1.9.0: Release
+
+ - Add package-lock.json (#82) @Pezmc
+
+#### 1.8.0: Release
+
+
+#### 1.7.0: Release
+
+
+#### 1.6.0: Release
+
+
+#### 1.5.0: Release
+
+
+#### 1.4.0: Release
+
+
+#### 1.3.0: Release
+
+
+#### 1.2.0: Release
+
+
+#### 1.1.0: Release
+
+ - Change default start port (#72) @hardillb
+ - Fix detection of default stack (#71) @knolleary
+ - Add getDefaultStackProperties function (#70) @hardillb
+ - Add flags to permit TCP/UDP inbound connections (#69) @Steve-Mcl
+
+#### 1.0.0: Release
+
+ - Update eslint and add default build action (#67) @knolleary
+ - Revert 64 (#66) @hardillb
+ - Install theme and project nodes into userDir (#64) @hardillb
+
+#### 0.10.0: Release
+
+
+#### 0.9.0: Release
+
+ - Prevent localfs crash when deleting project (#60) @Steve-Mcl
+
+#### 0.8.0: Release
+
+ - Add licenseType to launcher env (#58) @knolleary
+ - Add env var FORGE_TEAM_ID (#57) @Steve-Mcl
+ - Add FORGE_BROKER_* credentials to launcher env (#54) @knolleary
+
+#### 0.7.0: Release
+
+
+#### 0.6.0: Release
+
+ - Map FlowForge logout to nodered auth/revoke (#48) @Steve-Mcl
+ - Handle actions on deleted project (#49) @knolleary
+ - Update dependencies (#50) @knolleary
+ - Pass credentialSecret to env (supports auto gen credential secret PRs) (#47) @Steve-Mcl
+ - Add description to stack memory value (#46) @hardillb
+ - Make sure DB has right values for port + URL (#45) @hardillb
+
+#### 0.5.0: Release
+
+ - Modify nodered stack property regex to support beta releases (#43) @knolleary
+
+#### 0.4.0: Release
+
+ - Move setting project URL to before launcher started (#39) @hardillb
+ - Update localfs to new driver api (#37) @knolleary
+ - Update project automation (#38) @knolleary
+
+#### 0.3.0: Release
+
+ - Stop driver setting baseURL/forgeURL (#35) @knolleary
+ - Add basic stack support (#30) @knolleary
+ - Fix port allocation problem (main) (#32) @hardillb
+ - Stop opening cmd windows (#29) @hardillb
+ - Update package-lock.json (#28) @hardillb
+ - Automate npm publish on release (#27) @hardillb
+
+#### 0.2.0: Release
+
+ - Add shutdown hook (#24) @hardillb
+ - Add lint rules (#22) @hardillb
+ - Add project workflow automation (#20) @knolleary

package/LICENSE

@@ -0,0 +1,178 @@
+Copyright FlowForge Inc, and other contributors, https://flowforge.com/
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,24 @@
+# FlowFuse LocalFS Driver
+
+This will start/stop/monitor Node-RED instances and build separate useDirs for each instance
+
+## Configure
+
+The following environment variables (in the `.env` file) configure this driver
+
+ - CONTAINER_DRIVER=localfs
+ - LOCALFS_ROOT=<path/to/store/project/userDirs>
+ - LOCALFS_START_PORT=12080
+ - LOCALFS_NODE_PATH=<path/to/node/binary> (not required, but useful with nvm)
+
+## Node-RED Versions for Stacks
+
+To install copies of different versions of Node-RED for use by Project Stacks do the following:
+
+Assuming you wish to install Node-RED v2.2.2
+
+- In the `var` directory create a directory called `stacks`
+- In the `var/stacks` directory create a directory called `2.2.2`
+- in the `var/stacks/2.2.2` directory run `npm install --prefix . node-red@2.2.2`
+
+In the FlowFuse Admin settings create a Stack with the Node-RED version `2.2.2`

package/localfs.js

@@ -0,0 +1,555 @@
+/**
+ * Local Container driver
+ *
+ * Handles the creation and deletion of containers to back Projects
+ *
+ * This driver creates Projects backed by userDirectories on the local file system
+ *
+ * @module localfs
+ * @memberof forge.containers.drivers
+ *
+ */
+
+const fs = require('fs/promises')
+const { existsSync, openSync, close, readdirSync } = require('fs')
+const got = require('got')
+const path = require('path')
+const semver = require('semver')
+const childProcess = require('child_process')
+
+let initialPortNumber
+
+const fileHandles = {}
+
+let logger
+
+function getNextFreePort (ports) {
+    let port = initialPortNumber
+    while (ports.has(port)) {
+        port++
+    }
+    return port
+}
+
+async function createUserDirIfNeeded (userDir) {
+    if (!existsSync(userDir)) {
+        logger.info(`Creating settings directory: ${userDir}`)
+        await fs.mkdir(userDir)
+        await fs.mkdir(path.join(userDir, 'node_modules'))
+        const packageJSON = {
+            name: 'flowfuse-node-red-project',
+            description: 'A FlowFuse Node-RED Instance',
+            version: '0.0.1',
+            private: true
+        }
+        await fs.writeFile(path.join(userDir, 'package.json'),
+            JSON.stringify(packageJSON)
+        )
+    }
+}
+
+async function startProject (app, project, ProjectStack, userDir, port) {
+    const env = {} // JSON.parse(JSON.stringify(process.env))
+
+    const authTokens = await project.refreshAuthTokens()
+
+    env.FORGE_CLIENT_ID = authTokens.clientID
+    env.FORGE_CLIENT_SECRET = authTokens.clientSecret
+    env.FORGE_URL = app.config.api_url
+    env.FORGE_TEAM_ID = app.db.models.Team.encodeHashid(project.TeamId)
+    env.FORGE_PROJECT_ID = project.id
+    env.FORGE_PROJECT_TOKEN = authTokens.token
+    env.FORGE_NR_SECRET = await project.getSetting('credentialSecret')
+    // Inbound connections for localfs enabled by default
+    env.FORGE_NR_NO_TCP_IN = false // MVP. Future iteration could present this to YML or UI
+    env.FORGE_NR_NO_UDP_IN = false// MVP. Future iteration could present this to YML or UI
+    if (authTokens.broker) {
+        env.FORGE_BROKER_URL = authTokens.broker.url
+        env.FORGE_BROKER_USERNAME = authTokens.broker.username
+        env.FORGE_BROKER_PASSWORD = authTokens.broker.password
+    }
+    if (app.license.active()) {
+        env.FORGE_LICENSE_TYPE = 'ee'
+    }
+
+    if (app.config.node_path) {
+        env.PATH = process.env.PATH + path.delimiter + app.config.node_path
+    } else {
+        env.PATH = process.env.PATH
+    }
+
+    logger.debug(`Stack info ${JSON.stringify(ProjectStack?.properties)}`)
+    /*
+     * ProjectStack.properties will contain the stack properties for this project
+     *
+     * This driver specifices two properties:
+     *  - memory  : the value to apply to max-old-space-size
+     *              This gets passed to the project instance via the /:projectId/settings
+     *              endpoint - so this driver doesn't need to anything more with it
+     *  - nodered : the version of node-red to use
+     *              This driver needs to ensure the launcher is started using that
+     *              version of Node-RED. We assume the admin has installed it to a well-known
+     *              location using a set of instructions we provide (to be written)
+     */
+    if (ProjectStack?.properties.nodered) {
+        env.FORGE_NR_PATH = path.resolve(app.config.home, 'var/stacks', ProjectStack.properties.nodered)
+        logger.info(`Set FORGE_NR_PATH to ${env.FORGE_NR_PATH}`)
+    }
+
+    // logger.debug(`Project Environment Vars ${JSON.stringify(env)}`)
+
+    const out = openSync(path.join(userDir, '/out.log'), 'a')
+    const err = openSync(path.join(userDir, '/out.log'), 'a')
+
+    fileHandles[project.id] = {
+        out,
+        err
+    }
+
+    const processOptions = {
+        detached: true,
+        stdio: ['ignore', out, err],
+        windowsHide: true,
+        env,
+        cwd: userDir
+    }
+
+    // this needs work
+    // const ext = process.platform === 'win32' ? '.cmd' : ''
+
+    let execPath
+    for (let i = 0; i < module.paths.length; i++) {
+        // execPath = path.join(process.mainModule.paths[i], `.bin/flowforge-node-red${ext}`)
+        execPath = path.join(module.paths[i], '@flowfuse/nr-launcher/index.js')
+        if (existsSync(execPath)) {
+            break
+        }
+        execPath = null
+    }
+    if (!execPath) {
+        logger.info('Can not find flowfuse-node-red executable, no way to start projects')
+        process.exit(1)
+    }
+
+    logger.debug(`exec path ${execPath}`)
+
+    const args = [
+        execPath, // new
+        '-p',
+        port + 1000,
+        '--forgeURL',
+        app.config.base_url,
+        '--project',
+        project.id
+    // '--token',
+    // options.projectToken
+    ]
+
+    // const proc = childProcess.spawn(execPath, args, processOptions)
+    const proc = childProcess.spawn(process.execPath, args, processOptions)
+
+    proc.unref()
+
+    return proc.pid
+}
+
+function stopProject (app, project, projectSettings) {
+    try {
+        if (process.platform === 'win32') {
+            childProcess.exec(`taskkill /pid ${projectSettings.pid} /T /F`)
+        } else {
+            process.kill(projectSettings.pid, 'SIGTERM')
+        }
+    } catch (err) {
+    // probably means already stopped
+    }
+
+    if (fileHandles[project.id]) {
+        close(fileHandles[project.id].out)
+        close(fileHandles[project.id].err)
+        delete fileHandles[project.id]
+    }
+}
+
+async function getProjectList (driver) {
+    // Get a list of all projects - with the absolute minimum of fields returned
+    const projects = await driver._app.db.models.Project.findAll({
+        attributes: [
+            'id',
+            'state',
+            'ProjectStackId',
+            'TeamId'
+        ],
+        include: [
+            {
+                model: driver._app.db.models.ProjectSettings,
+                where: { key: driver._app.db.sequelize.or('port', 'path') }
+            }
+        ]
+    })
+    projects.forEach(async (project) => {
+        const projectSettings = {}
+        // Remap the project settings to make them accessible
+        project.ProjectSettings.forEach(ps => {
+            projectSettings[ps.key] = ps.value
+        })
+        driver._usedPorts.add(projectSettings.port)
+        if (driver._projects[project.id] === undefined) {
+            driver._projects[project.id] = {
+                state: 'unknown'
+            }
+        }
+        project._settings = projectSettings
+    })
+    return projects
+}
+
+async function checkExistingProjects (driver) {
+    logger.debug('[localfs] Checking project status')
+
+    const projects = await getProjectList(driver)
+    projects.forEach(async (project) => {
+        const projectSettings = project._settings
+        // Suspended projects don't get restarted
+        if (project.state === 'suspended') {
+            return
+        }
+
+        logger.debug(`[localfs] Project ${project.id} port ${projectSettings.port}`)
+
+        const directory = path.join(driver._rootDir, project.id)
+        await createUserDirIfNeeded(directory)
+
+        try {
+            const info = await got.get(`http://localhost:${projectSettings.port + 1000}/flowforge/info`, {
+                timeout: {
+                    request: 1000
+                }
+            }).json()
+            if (project.id !== info.id) {
+                // Running project doesn't match db
+                logger.warn(`[localfs] Project ${project.id} expected on port ${projectSettings.port}. Found ${info.id}`)
+                // TODO should do something here...
+            } else {
+                driver._projects[project.id] = {
+                    state: 'started'
+                }
+            }
+        } catch (err) {
+            logger.info(`Starting project ${project.id} on port ${projectSettings.port}`)
+
+            const projectStack = await project.getProjectStack()
+
+            const pid = await startProject(driver._app, project, projectStack, projectSettings.path, projectSettings.port)
+            await project.updateSetting('pid', pid)
+            driver._projects[project.id] = {
+                state: 'started'
+            }
+        }
+    })
+}
+
+module.exports = {
+    /**
+     * Initialises this driver
+     * @param {string} app - the Vue application
+     * @param {object} options - A set of configuration options for the driver
+     * @return {forge.containers.ProjectArguments}
+     */
+    init: async (app, options) => {
+        this._app = app
+        this._options = options
+        this._projects = {}
+        this._usedPorts = new Set()
+        // TODO need a better way to find this location?
+        this._rootDir = path.resolve(app.config.home, 'var/projects')
+        this._stackDir = path.resolve(app.config.home, 'var/stacks')
+
+        initialPortNumber = app.config.driver.options?.start_port || 12080
+
+        logger = app.log
+
+        if (!existsSync(this._rootDir)) {
+            await fs.mkdir(this._rootDir)
+        }
+
+        // Ensure we have our local list of projects up to date
+        await getProjectList(this)
+        this._initialCheckTimeout = setTimeout(() => {
+            app.log.debug('[localfs] Restarting projects')
+            checkExistingProjects(this)
+        }, 1000)
+        this._checkInterval = setInterval(() => {
+            checkExistingProjects(this)
+        }, 60000)
+        return {
+            stack: {
+                properties: {
+                    nodered: {
+                        label: 'Node-RED Version',
+                        description: 'This must match a version installed on the platform. See the docs for how to setup stacks locally.',
+                        validate: '^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(-.*)?$',
+                        invalidMessage: 'Invalid version number - expected x.y.z'
+                    },
+                    memory: {
+                        label: 'Memory (MB)',
+                        description: 'This is the point at which the runtime will start garbage collecting unused memory. Recommended minimum: 256',
+                        validate: '^[1-9]\\d+$',
+                        invalidMessage: 'Invalid value - must be a number'
+                    }
+                }
+            }
+        }
+    },
+    /**
+     * Start a Project
+     * @param {Project} project - the project model instance
+     */
+    start: async (project) => {
+        // Setup project directory
+        const directory = path.join(this._rootDir, project.id)
+        await createUserDirIfNeeded(directory)
+
+        // Check if the project has a port assigned already
+        let port = await project.getSetting('port')
+
+        if (port === undefined) {
+            // This project has never been run, so assign a new port to it
+            port = getNextFreePort(this._usedPorts)
+            this._usedPorts.add(port)
+        }
+
+        this._projects[project.id] = {
+            state: 'starting'
+        }
+
+        await project.updateSettings({
+            path: directory,
+            port
+        })
+
+        const baseURL = new URL(this._app.config.base_url)
+        baseURL.port = port
+        project.url = baseURL.href
+        await project.save()
+
+        // Kick-off the project start and return the promise to let it
+        // complete asynchronously
+        return startProject(this._app, project, project.ProjectStack, directory, port).then(async pid => {
+            return new Promise(resolve => {
+                // These is a race condition when running locally where the UI
+                // creates a project then immediate reloads it. That can hit
+                // a timing window where the project creation completes mid-request
+                setTimeout(async () => {
+                    logger.debug(`PID ${pid}, port, ${port}, directory, ${directory}`)
+                    await project.updateSetting('pid', pid)
+                    this._projects[project.id].state = 'started'
+                    resolve()
+                }, 1000)
+            })
+        })
+    },
+    /**
+     * Stops a project from running, but doesn't clear its state as it could
+     * get restarted and we want to preserve port number and user dir
+     * @param {*} project
+     */
+    stop: async (project) => {
+        const projectSettings = await project.getAllSettings()
+        this._projects[project.id].state = 'suspended'
+        stopProject(this._app, project, projectSettings)
+    },
+
+    /**
+     * Removes a Project
+     * @param {Project} project - the project model instance
+     * @return {Object}
+     */
+    remove: async (project) => {
+        const projectSettings = await project.getAllSettings()
+        stopProject(this._app, project, projectSettings)
+
+        setTimeout(async () => {
+            try {
+                await fs.rm(projectSettings.path, { recursive: true, force: true })
+            } catch (error) {
+                logger.warn(`Error removing project files: ${projectSettings.path}`)
+            }
+        }, 5000)
+
+        this._usedPorts.delete(projectSettings.port)
+        delete this._projects[project.id]
+    },
+    /**
+    * Retrieves details of a project's container
+    * @param {Project} project - the project model instance
+    * @return {Object}
+    */
+    details: async (project) => {
+        if (this._projects[project.id] === undefined) {
+            return { state: 'unknown' }
+        }
+        if (this._projects[project.id].state !== 'started') {
+            // We should only poll the launcher if we think it is running.
+            // Otherwise, return our cached state
+            return {
+                state: this._projects[project.id].state
+            }
+        }
+        const port = await project.getSetting('port')
+        const infoURL = 'http://localhost:' + (port + 1000) + '/flowforge/info'
+        try {
+            const info = JSON.parse((await got.get(infoURL)).body)
+            return info
+        } catch (err) {
+            console.log(err)
+            // TODO
+        }
+    },
+    /**
+     * Returns the settings for the project
+     * @param {Project} project - the project model instance
+     */
+    settings: async (project) => {
+        const settings = {}
+        if (project) {
+            settings.projectID = project.id
+            settings.rootDir = this._rootDir
+            settings.userDir = project.id
+            settings.port = await project.getSetting('port')
+            settings.env = {
+                NODE_PATH: path.join(this._app.config.home, 'app', 'node_modules')
+            }
+        }
+        // settings.state is set by the core forge app before this returns to
+        // the launcher
+
+        // settings.stack is set by the core forge app
+
+        return settings
+    },
+
+    /**
+     * Starts the flows
+     * @param {Project} project - the project model instance
+     */
+    startFlows: async (project) => {
+        if (this._projects[project.id] === undefined) {
+            throw new Error('Project cannot start flows')
+        }
+        const port = await project.getSetting('port')
+        await got.post('http://localhost:' + (port + 1000) + '/flowforge/command', {
+            json: {
+                cmd: 'start'
+            }
+        })
+    },
+    /**
+   * Stops the flows
+   * @param {Project} project - the project model instance
+   * @return {forge.Status}
+   */
+    stopFlows: async (project) => {
+        if (this._projects[project.id] === undefined) {
+            throw new Error('Project cannot stop flows')
+        }
+        const port = await project.getSetting('port')
+        await got.post('http://localhost:' + (port + 1000) + '/flowforge/command', {
+            json: {
+                cmd: 'stop'
+            }
+        })
+    },
+    /**
+   * Restarts the flows
+   * @param {Project} project - the project model instance
+   * @return {forge.Status}
+   */
+    restartFlows: async (project) => {
+        if (this._projects[project.id] === undefined) {
+            throw new Error('Project cannot restart flows')
+        }
+        const port = await project.getSetting('port')
+        await got.post('http://localhost:' + (port + 1000) + '/flowforge/command', {
+            json: {
+                cmd: 'restart'
+            }
+        })
+    },
+    /**
+   * Logout Node-RED instance
+   * @param {Project} project - the project model instance
+   * @param {string} token - the node-red token to revoke
+   * @return {forge.Status}
+   */
+    revokeUserToken: async (project, token) => { // logout:nodered(step-3)
+        const port = await project.getSetting('port')
+        try {
+            this._app.log.debug(`[localfs] Project ${project.id} - logging out node-red instance`)
+            await got.post('http://localhost:' + (port + 1000) + '/flowforge/command', { // logout:nodered(step-4)
+                json: {
+                    cmd: 'logout',
+                    token
+                }
+            })
+        } catch (error) {
+            logger.error(`[localfs] Project ${project.id} - error in 'revokeUserToken': ${error.stack}`)
+        }
+    },
+
+    /**
+   * Get a Project's logs
+   * @param {Project} project - the project model instance
+   * @return {array} logs
+   */
+    logs: async (project) => {
+        if (this._projects[project.id] === undefined) {
+            throw new Error('Cannot get project logs')
+        }
+        const port = await project.getSetting('port')
+        const result = await got.get('http://localhost:' + (port + 1000) + '/flowforge/logs').json()
+        return result
+    },
+    /**
+     * Shutdown driver
+     */
+    shutdown: async () => {
+        clearTimeout(this._initialCheckTimeout)
+        clearInterval(this._checkInterval)
+    },
+    /**
+     * getDefaultStackProperties
+     */
+    getDefaultStackProperties: () => {
+        const properties = {
+            memory: 256,
+            ...this._app.config.driver.options?.default_stack
+        }
+
+        // allow stack value to be passing in from config
+        if (!properties.nodered) {
+            const entries = readdirSync(this._stackDir, { withFileTypes: true })
+            const directories = entries.filter(dir => {
+                return dir.isDirectory() && semver.valid(dir.name)
+            }).map(dir => dir.name)
+                .sort((a, b) => {
+                    if (semver.gt(a, b)) {
+                        return -1
+                    } else {
+                        return 1
+                    }
+                })
+            if (directories[0]) {
+                properties.nodered = directories[0]
+            } else {
+                throw new Error(`No Stacks found in ${this._stackDir}`)
+            }
+        } else {
+            const preconfiguredStack = path.join(this._stackDir, properties.nodered)
+            if (!fs.existsSync(preconfiguredStack)) {
+                throw new Error(`Stack not found: ${preconfiguredStack}`)
+            }
+        }
+        return properties
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@flowfuse/driver-localfs",
+    "version": "1.14.0",
+    "description": "Local Filesystem FlowFuse Project driver",
+    "main": "localfs.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "lint": "eslint -c .eslintrc *.js",
+        "lint:fix": "eslint -c .eslintrc *.js --fix"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/FlowFuse/driver-localfs.git"
+    },
+    "bugs": {
+        "url": "https://github.com/FlowFuse/driver-localfs/issues"
+    },
+    "homepage": "https://github.com/FlowFuse/driver-localfs#readme",
+    "author": {
+        "name": "FlowFuse Inc."
+    },
+    "license": "Apache-2.0",
+    "dependencies": {
+        "@flowfuse/nr-launcher": "^1.14.0",
+        "got": "^11.8.5",
+        "semver": "^7.3.8"
+    },
+    "devDependencies": {
+        "eslint": "^8.25.0",
+        "eslint-config-standard": "^17.0.0"
+    }
+}