merge 036, everything broken

container-runtime/.gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+bundle.js
+startInit.js
+service/
+service.js
+alpine.squashfs
+/tmp

container-runtime/Dockerfile

@@ -0,0 +1,4 @@
+FROM node:18-alpine
+
+ADD ./startInit.js /usr/local/lib/startInit.js
+ADD ./entrypoint.sh /usr/local/bin/entrypoint.sh

container-runtime/RPCSpec.md

@@ -0,0 +1,59 @@
+# Container RPC SERVER Specification
+
+## Methods
+
+### init
+initialize runtime (mount `/proc`, `/sys`, `/dev`, and `/run` to each image in `/media/images`)
+
+called after os has mounted js and images to the container
+#### args
+`[]`
+#### response
+`null`
+
+### exit
+shutdown runtime
+#### args
+`[]`
+#### response
+`null`
+
+### start
+run main method if not already running
+#### args
+`[]`
+#### response
+`null`
+
+### stop
+stop main method by sending SIGTERM to child processes, and SIGKILL after timeout
+#### args
+`{ timeout: millis }`
+#### response
+`null`
+
+### execute
+run a specific package procedure
+#### args 
+```ts
+{
+    procedure: JsonPath,
+    input: any,
+    timeout: millis,
+}
+```
+#### response
+`any`
+
+### sandbox
+run a specific package procedure in sandbox mode
+#### args 
+```ts
+{
+    procedure: JsonPath,
+    input: any,
+    timeout: millis,
+}
+```
+#### response
+`any`

container-runtime/containerRuntime.rc

@@ -0,0 +1,10 @@
+#!/sbin/openrc-run
+
+name=containerRuntime
+#cfgfile="/etc/containerRuntime/containerRuntime.conf"
+command="/usr/bin/node"
+command_args="--experimental-detect-module --unhandled-rejections=warn /usr/lib/startos/init/index.js"
+pidfile="/run/containerRuntime.pid"
+command_background="yes"
+output_log="/var/log/containerRuntime.log"
+error_log="/var/log/containerRuntime.err"

container-runtime/download-base-image.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+set -e
+
+DISTRO=alpine
+VERSION=3.19
+ARCH=${ARCH:-$(uname -m)}
+FLAVOR=default
+
+if [ "$ARCH" = "x86_64" ]; then
+    ARCH=amd64
+elif [ "$ARCH" = "aarch64" ]; then
+    ARCH=arm64
+fi
+
+curl https://images.linuxcontainers.org/$(curl --silent https://images.linuxcontainers.org/meta/1.0/index-system | grep "^$DISTRO;$VERSION;$ARCH;$FLAVOR;" | head -n1 | sed 's/^.*;//g')/rootfs.squashfs --output alpine.squashfs

container-runtime/install-dist-deps.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+set -e
+
+cat ./package.json | sed 's/file:\.\([.\/]\)/file:..\/.\1/g' > ./dist/package.json
+cat ./package-lock.json | sed 's/"\.\([.\/]\)/"..\/.\1/g' > ./dist/package-lock.json
+
+npm --prefix dist ci --omit=dev

container-runtime/mkcontainer.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -e
+
+IMAGE=$1
+
+if [ -z "$IMAGE" ]; then
+    >&2 echo "usage: $0 <image id>"
+    exit 1
+fi
+
+if ! [ -d "/media/images/$IMAGE" ]; then
+    >&2 echo "image does not exist"
+    exit 1
+fi
+
+container=$(mktemp -d)
+mkdir -p $container/rootfs $container/upper $container/work
+mount -t overlay -olowerdir=/media/images/$IMAGE,upperdir=$container/upper,workdir=$container/work overlay $container/rootfs
+
+rootfs=$container/rootfs
+
+for special in dev sys proc run; do
+    mkdir -p $rootfs/$special
+    mount --bind /$special $rootfs/$special
+done
+
+echo $rootfs

container-runtime/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "start-init",
+  "version": "0.0.0",
+  "description": "We want to be the sdk intermitent for the system",
+  "module": "./index.js",
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "prettier --write '**/*.ts' && rm -rf dist && tsc",
+    "tsc": "rm -rf dist; tsc"
+  },
+  "author": "",
+  "prettier": {
+    "trailingComma": "all",
+    "tabWidth": 2,
+    "semi": false,
+    "singleQuote": false
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@start9labs/start-sdk": "file:../sdk/dist",
+    "esbuild-plugin-resolve": "^2.0.0",
+    "filebrowser": "^1.0.0",
+    "isomorphic-fetch": "^3.0.0",
+    "node-fetch": "^3.1.0",
+    "ts-matches": "^5.4.1",
+    "tslib": "^2.5.3",
+    "typescript": "^5.1.3",
+    "yaml": "^2.3.1"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.1.62",
+    "@swc/core": "^1.3.65",
+    "@types/node": "^20.11.13",
+    "prettier": "^3.2.5",
+    "typescript": ">5.2"
+  }
+}

container-runtime/readme.md

@@ -0,0 +1,86 @@
+## Testing
+
+So, we are going to
+
+1. create a fake server
+2. pretend socket server os (while the fake server is running)
+3. Run a fake effects system (while 1/2 are running)
+
+In order to simulate that we created a server like the start-os and
+a fake server (in this case I am using syncthing-wrapper)
+
+### TODO
+
+Undo the packing that I have done earlier, and hijack the embassy.js to use the bundle service + code
+
+Converting embassy.js -> service.js
+
+```sequence {theme="hand"}
+startOs ->> startInit.js: Rpc Call
+startInit.js ->> service.js: Rpc Converted into js code
+```
+
+### Create a fake server
+
+```bash
+run_test () {
+    (
+        set -e
+        libs=/home/jh/Projects/start-os/libs/start_init
+        sockets=/tmp/start9
+        service=/home/jh/Projects/syncthing-wrapper
+
+        docker run  \
+            -v $libs:/libs \
+            -v $service:/service \
+            -w /libs \
+            --rm node:18-alpine \
+            sh -c "
+                npm i &&
+                npm run bundle:esbuild  &&
+                npm run bundle:service
+            "
+
+
+
+        docker run  \
+            -v ./libs/start_init/:/libs \
+            -w /libs \
+            --rm node:18-alpine \
+            sh -c "
+                npm i &&
+                npm run bundle:esbuild
+            "
+
+
+
+        rm -rf $sockets  || true
+        mkdir -p $sockets/sockets
+        cd $service
+        docker run \
+            -v $libs:/start-init \
+            -v $sockets:/start9 \
+            --rm -it $(docker build -q .) sh -c "
+                apk add nodejs &&
+                node /start-init/bundleEs.js
+            "
+    )
+}
+run_test
+```
+
+### Pretend Socket Server OS
+
+First we are going to create our fake server client with the bash then send it the json possible data
+
+```bash
+sudo socat - unix-client:/tmp/start9/sockets/rpc.sock
+```
+
+<!-- prettier-ignore -->
+```json
+{"id":"a","method":"run","params":{"methodName":"/dependencyMounts","methodArgs":[]}}
+{"id":"a","method":"run","params":{"methodName":"/actions/test","methodArgs":{"input":{"id": 1}}}}
+{"id":"b","method":"run","params":{"methodName":"/actions/test","methodArgs":{"id": 1}}}
+
+```

container-runtime/rmcontainer.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+rootfs=$1
+if [ -z "$rootfs" ]; then
+    >&2 echo "usage: $0 <container rootfs path>"
+    exit 1
+fi
+
+umount --recursive $rootfs
+rm -rf $rootfs/..

container-runtime/src/Adapters/HostSystemStartOs.ts

@@ -0,0 +1,295 @@
+import { types as T } from "@start9labs/start-sdk"
+import * as net from "net"
+import { object, string, number, literals, some, unknown } from "ts-matches"
+import { Effects } from "../Models/Effects"
+
+import { CallbackHolder } from "../Models/CallbackHolder"
+const matchRpcError = object({
+  error: object(
+    {
+      code: number,
+      message: string,
+      data: some(
+        string,
+        object(
+          {
+            details: string,
+            debug: string,
+          },
+          ["debug"],
+        ),
+      ),
+    },
+    ["data"],
+  ),
+})
+const testRpcError = matchRpcError.test
+const testRpcResult = object({
+  result: unknown,
+}).test
+type RpcError = typeof matchRpcError._TYPE
+
+const SOCKET_PATH = "/media/startos/rpc/host.sock"
+const MAIN = "/main" as const
+export class HostSystemStartOs implements Effects {
+  static of(callbackHolder: CallbackHolder) {
+    return new HostSystemStartOs(callbackHolder)
+  }
+
+  constructor(readonly callbackHolder: CallbackHolder) {}
+  id = 0
+  rpcRound<K extends keyof Effects | "getStore" | "setStore">(
+    method: K,
+    params: unknown,
+  ) {
+    const id = this.id++
+    const client = net.createConnection({ path: SOCKET_PATH }, () => {
+      client.write(
+        JSON.stringify({
+          id,
+          method,
+          params,
+        }) + "\n",
+      )
+    })
+    let bufs: Buffer[] = []
+    return new Promise((resolve, reject) => {
+      client.on("data", (data) => {
+        try {
+          bufs.push(data)
+          if (data.reduce((acc, x) => acc || x == 10, false)) {
+            const res: unknown = JSON.parse(
+              Buffer.concat(bufs).toString().split("\n")[0],
+            )
+            if (testRpcError(res)) {
+              let message = res.error.message
+              console.error({ method, params, hostSystemStartOs: true })
+              if (string.test(res.error.data)) {
+                message += ": " + res.error.data
+                console.error(res.error.data)
+              } else {
+                if (res.error.data?.details) {
+                  message += ": " + res.error.data.details
+                  console.error(res.error.data.details)
+                }
+                if (res.error.data?.debug) {
+                  message += "\n" + res.error.data.debug
+                  console.error("Debug: " + res.error.data.debug)
+                }
+              }
+              reject(new Error(`${message}@${method}`))
+            } else if (testRpcResult(res)) {
+              resolve(res.result)
+            } else {
+              reject(new Error(`malformed response ${JSON.stringify(res)}`))
+            }
+          }
+        } catch (error) {
+          reject(error)
+        }
+        client.end()
+      })
+      client.on("error", (error) => {
+        reject(error)
+      })
+    })
+  }
+
+  bind(...[options]: Parameters<T.Effects["bind"]>) {
+    return this.rpcRound("bind", options) as ReturnType<T.Effects["bind"]>
+  }
+  clearBindings(...[]: Parameters<T.Effects["clearBindings"]>) {
+    return this.rpcRound("clearBindings", null) as ReturnType<
+      T.Effects["clearBindings"]
+    >
+  }
+  clearServiceInterfaces(
+    ...[]: Parameters<T.Effects["clearServiceInterfaces"]>
+  ) {
+    return this.rpcRound("clearServiceInterfaces", null) as ReturnType<
+      T.Effects["clearServiceInterfaces"]
+    >
+  }
+  createOverlayedImage(options: {
+    imageId: string
+  }): Promise<[string, string]> {
+    return this.rpcRound("createOverlayedImage", options) as ReturnType<
+      T.Effects["createOverlayedImage"]
+    >
+  }
+  destroyOverlayedImage(options: { guid: string }): Promise<void> {
+    return this.rpcRound("destroyOverlayedImage", options) as ReturnType<
+      T.Effects["destroyOverlayedImage"]
+    >
+  }
+  executeAction(...[options]: Parameters<T.Effects["executeAction"]>) {
+    return this.rpcRound("executeAction", options) as ReturnType<
+      T.Effects["executeAction"]
+    >
+  }
+  exists(...[packageId]: Parameters<T.Effects["exists"]>) {
+    return this.rpcRound("exists", packageId) as ReturnType<T.Effects["exists"]>
+  }
+  exportAction(...[options]: Parameters<T.Effects["exportAction"]>) {
+    return this.rpcRound("exportAction", options) as ReturnType<
+      T.Effects["exportAction"]
+    >
+  }
+  exportServiceInterface: Effects["exportServiceInterface"] = (
+    ...[options]: Parameters<Effects["exportServiceInterface"]>
+  ) => {
+    return this.rpcRound("exportServiceInterface", options) as ReturnType<
+      T.Effects["exportServiceInterface"]
+    >
+  }
+  exposeForDependents(...[options]: any) {
+    return this.rpcRound("exposeForDependents", null) as ReturnType<
+      T.Effects["exposeForDependents"]
+    >
+  }
+  exposeUi(...[options]: Parameters<T.Effects["exposeUi"]>) {
+    return this.rpcRound("exposeUi", options) as ReturnType<
+      T.Effects["exposeUi"]
+    >
+  }
+  getConfigured(...[]: Parameters<T.Effects["getConfigured"]>) {
+    return this.rpcRound("getConfigured", null) as ReturnType<
+      T.Effects["getConfigured"]
+    >
+  }
+  getContainerIp(...[]: Parameters<T.Effects["getContainerIp"]>) {
+    return this.rpcRound("getContainerIp", null) as ReturnType<
+      T.Effects["getContainerIp"]
+    >
+  }
+  getHostInfo: Effects["getHostInfo"] = (...[allOptions]: any[]) => {
+    const options = {
+      ...allOptions,
+      callback: this.callbackHolder.addCallback(allOptions.callback),
+    }
+    return this.rpcRound("getHostInfo", options) as ReturnType<
+      T.Effects["getHostInfo"]
+    > as any
+  }
+  getServiceInterface(
+    ...[options]: Parameters<T.Effects["getServiceInterface"]>
+  ) {
+    return this.rpcRound("getServiceInterface", {
+      ...options,
+      callback: this.callbackHolder.addCallback(options.callback),
+    }) as ReturnType<T.Effects["getServiceInterface"]>
+  }
+
+  getPrimaryUrl(...[options]: Parameters<T.Effects["getPrimaryUrl"]>) {
+    return this.rpcRound("getPrimaryUrl", {
+      ...options,
+      callback: this.callbackHolder.addCallback(options.callback),
+    }) as ReturnType<T.Effects["getPrimaryUrl"]>
+  }
+  getServicePortForward(
+    ...[options]: Parameters<T.Effects["getServicePortForward"]>
+  ) {
+    return this.rpcRound("getServicePortForward", options) as ReturnType<
+      T.Effects["getServicePortForward"]
+    >
+  }
+  getSslCertificate(options: Parameters<T.Effects["getSslCertificate"]>[0]) {
+    return this.rpcRound("getSslCertificate", options) as ReturnType<
+      T.Effects["getSslCertificate"]
+    >
+  }
+  getSslKey(options: Parameters<T.Effects["getSslKey"]>[0]) {
+    return this.rpcRound("getSslKey", options) as ReturnType<
+      T.Effects["getSslKey"]
+    >
+  }
+  getSystemSmtp(...[options]: Parameters<T.Effects["getSystemSmtp"]>) {
+    return this.rpcRound("getSystemSmtp", {
+      ...options,
+      callback: this.callbackHolder.addCallback(options.callback),
+    }) as ReturnType<T.Effects["getSystemSmtp"]>
+  }
+  listServiceInterfaces(
+    ...[options]: Parameters<T.Effects["listServiceInterfaces"]>
+  ) {
+    return this.rpcRound("listServiceInterfaces", {
+      ...options,
+      callback: this.callbackHolder.addCallback(options.callback),
+    }) as ReturnType<T.Effects["listServiceInterfaces"]>
+  }
+  mount(...[options]: Parameters<T.Effects["mount"]>) {
+    return this.rpcRound("mount", options) as ReturnType<T.Effects["mount"]>
+  }
+  removeAction(...[options]: Parameters<T.Effects["removeAction"]>) {
+    return this.rpcRound("removeAction", options) as ReturnType<
+      T.Effects["removeAction"]
+    >
+  }
+  removeAddress(...[options]: Parameters<T.Effects["removeAddress"]>) {
+    return this.rpcRound("removeAddress", options) as ReturnType<
+      T.Effects["removeAddress"]
+    >
+  }
+  restart(...[]: Parameters<T.Effects["restart"]>) {
+    return this.rpcRound("restart", null)
+  }
+  reverseProxy(...[options]: Parameters<T.Effects["reverseProxy"]>) {
+    return this.rpcRound("reverseProxy", options) as ReturnType<
+      T.Effects["reverseProxy"]
+    >
+  }
+  running(...[packageId]: Parameters<T.Effects["running"]>) {
+    return this.rpcRound("running", { packageId }) as ReturnType<
+      T.Effects["running"]
+    >
+  }
+  // runRsync(...[options]: Parameters<T.Effects[""]>) {
+  //
+  // return this.rpcRound('executeAction', options) as ReturnType<T.Effects["executeAction"]>
+  //
+  // return this.rpcRound('executeAction', options) as ReturnType<T.Effects["executeAction"]>
+  // }
+  setConfigured(...[configured]: Parameters<T.Effects["setConfigured"]>) {
+    return this.rpcRound("setConfigured", { configured }) as ReturnType<
+      T.Effects["setConfigured"]
+    >
+  }
+  setDependencies(
+    ...[dependencies]: Parameters<T.Effects["setDependencies"]>
+  ): ReturnType<T.Effects["setDependencies"]> {
+    return this.rpcRound("setDependencies", { dependencies }) as ReturnType<
+      T.Effects["setDependencies"]
+    >
+  }
+  setHealth(...[options]: Parameters<T.Effects["setHealth"]>) {
+    return this.rpcRound("setHealth", options) as ReturnType<
+      T.Effects["setHealth"]
+    >
+  }
+
+  setMainStatus(o: { status: "running" | "stopped" }): Promise<void> {
+    return this.rpcRound("setMainStatus", o) as ReturnType<
+      T.Effects["setHealth"]
+    >
+  }
+
+  shutdown(...[]: Parameters<T.Effects["shutdown"]>) {
+    return this.rpcRound("shutdown", null)
+  }
+  stopped(...[packageId]: Parameters<T.Effects["stopped"]>) {
+    return this.rpcRound("stopped", { packageId }) as ReturnType<
+      T.Effects["stopped"]
+    >
+  }
+  store: T.Effects["store"] = {
+    get: async (options: any) =>
+      this.rpcRound("getStore", {
+        ...options,
+        callback: this.callbackHolder.addCallback(options.callback),
+      }) as any,
+    set: async (options: any) =>
+      this.rpcRound("setStore", options) as ReturnType<
+        T.Effects["store"]["set"]
+      >,
+  }
+}

container-runtime/src/Adapters/RpcListener.ts

@@ -0,0 +1,312 @@
+// @ts-check
+
+import * as net from "net"
+import {
+  object,
+  some,
+  string,
+  literal,
+  array,
+  number,
+  matches,
+  any,
+  shape,
+  anyOf,
+} from "ts-matches"
+
+import { types as T } from "@start9labs/start-sdk"
+import * as CP from "child_process"
+import * as Mod from "module"
+import * as fs from "fs"
+
+import { CallbackHolder } from "../Models/CallbackHolder"
+import { AllGetDependencies } from "../Interfaces/AllGetDependencies"
+import { HostSystem } from "../Interfaces/HostSystem"
+import { jsonPath } from "../Models/JsonPath"
+import { System } from "../Interfaces/System"
+type MaybePromise<T> = T | Promise<T>
+export const matchRpcResult = anyOf(
+  object({ result: any }),
+  object({
+    error: object(
+      {
+        code: number,
+        message: string,
+        data: object(
+          {
+            details: string,
+            debug: any,
+          },
+          ["details", "debug"],
+        ),
+      },
+      ["data"],
+    ),
+  }),
+)
+export type RpcResult = typeof matchRpcResult._TYPE
+type SocketResponse = { jsonrpc: "2.0"; id: IdType } & RpcResult
+
+const SOCKET_PARENT = "/media/startos/rpc"
+const SOCKET_PATH = "/media/startos/rpc/service.sock"
+const jsonrpc = "2.0" as const
+
+const idType = some(string, number, literal(null))
+type IdType = null | string | number
+const runType = object({
+  id: idType,
+  method: literal("execute"),
+  params: object(
+    {
+      procedure: string,
+      input: any,
+      timeout: number,
+    },
+    ["timeout"],
+  ),
+})
+const sandboxRunType = object({
+  id: idType,
+  method: literal("sandbox"),
+  params: object(
+    {
+      procedure: string,
+      input: any,
+      timeout: number,
+    },
+    ["timeout"],
+  ),
+})
+const callbackType = object({
+  id: idType,
+  method: literal("callback"),
+  params: object({
+    callback: string,
+    args: array,
+  }),
+})
+const initType = object({
+  id: idType,
+  method: literal("init"),
+})
+const exitType = object({
+  id: idType,
+  method: literal("exit"),
+})
+const evalType = object({
+  id: idType,
+  method: literal("eval"),
+  params: object({
+    script: string,
+  }),
+})
+
+const jsonParse = (x: Buffer) => JSON.parse(x.toString())
+function reduceMethod(
+  methodArgs: object,
+  effects: HostSystem,
+): (previousValue: any, currentValue: string) => any {
+  return (x: any, method: string) =>
+    Promise.resolve(x)
+      .then((x) => x[method])
+      .then((x) =>
+        typeof x !== "function"
+          ? x
+          : x({
+              ...methodArgs,
+              effects,
+            }),
+      )
+}
+
+const hasId = object({ id: idType }).test
+export class RpcListener {
+  unixSocketServer = net.createServer(async (server) => {})
+  private _system: System | undefined
+  private _effects: HostSystem | undefined
+
+  constructor(
+    readonly getDependencies: AllGetDependencies,
+    private callbacks = new CallbackHolder(),
+  ) {
+    if (!fs.existsSync(SOCKET_PARENT)) {
+      fs.mkdirSync(SOCKET_PARENT, { recursive: true })
+    }
+    this.unixSocketServer.listen(SOCKET_PATH)
+
+    this.unixSocketServer.on("connection", (s) => {
+      let id: IdType = null
+      const captureId = <X>(x: X) => {
+        if (hasId(x)) id = x.id
+        return x
+      }
+      const logData =
+        (location: string) =>
+        <X>(x: X) => {
+          console.log({
+            location,
+            stringified: JSON.stringify(x),
+            type: typeof x,
+            id,
+          })
+          return x
+        }
+      const mapError = (error: any): SocketResponse => ({
+        jsonrpc,
+        id,
+        error: {
+          message: typeof error,
+          data: {
+            details: error?.message ?? String(error),
+            debug: error?.stack,
+          },
+          code: 0,
+        },
+      })
+      const writeDataToSocket = (x: SocketResponse) =>
+        new Promise((resolve) => s.write(JSON.stringify(x), resolve))
+      s.on("data", (a) =>
+        Promise.resolve(a)
+          .then(logData("dataIn"))
+          .then(jsonParse)
+          .then(captureId)
+          .then((x) => this.dealWithInput(x))
+          .catch(mapError)
+          .then(logData("response"))
+          .then(writeDataToSocket)
+          .finally(() => void s.end()),
+      )
+    })
+  }
+
+  private get effects() {
+    return this.getDependencies.hostSystem()(this.callbacks)
+  }
+
+  private get system() {
+    if (!this._system) throw new Error("System not initialized")
+    return this._system
+  }
+
+  private dealWithInput(input: unknown): MaybePromise<SocketResponse> {
+    return matches(input)
+      .when(some(runType, sandboxRunType), async ({ id, params }) => {
+        const system = this.system
+        const procedure = jsonPath.unsafeCast(params.procedure)
+        return system
+          .execute(this.effects, {
+            procedure,
+            input: params.input,
+            timeout: params.timeout,
+          })
+          .then((result) => ({
+            jsonrpc,
+            id,
+            ...result,
+          }))
+          .then((x) => {
+            if (
+              ("result" in x && x.result === undefined) ||
+              !("error" in x || "result" in x)
+            )
+              (x as any).result = null
+            return x
+          })
+          .catch((error) => ({
+            jsonrpc,
+            id,
+            error: {
+              code: 0,
+              message: typeof error,
+              data: { details: "" + error, debug: error?.stack },
+            },
+          }))
+      })
+      .when(callbackType, async ({ id, params: { callback, args } }) =>
+        Promise.resolve(this.callbacks.callCallback(callback, args))
+          .then((result) => ({
+            jsonrpc,
+            id,
+            result,
+          }))
+          .catch((error) => ({
+            jsonrpc,
+            id,
+
+            error: {
+              code: 0,
+              message: typeof error,
+              data: {
+                details: error?.message ?? String(error),
+                debug: error?.stack,
+              },
+            },
+          })),
+      )
+      .when(exitType, async ({ id }) => {
+        if (this._system) this._system.exit(this.effects)
+        delete this._system
+        delete this._effects
+
+        return {
+          jsonrpc,
+          id,
+          result: null,
+        }
+      })
+      .when(initType, async ({ id }) => {
+        this._system = await this.getDependencies.system()
+
+        return {
+          jsonrpc,
+          id,
+          result: null,
+        }
+      })
+      .when(evalType, async ({ id, params }) => {
+        const result = await new Function(
+          `return (async () => { return (${params.script}) }).call(this)`,
+        ).call({
+          listener: this,
+          require: require,
+        })
+        return {
+          jsonrpc,
+          id,
+          result: !["string", "number", "boolean", "null", "object"].includes(
+            typeof result,
+          )
+            ? null
+            : result,
+        }
+      })
+      .when(shape({ id: idType, method: string }), ({ id, method }) => ({
+        jsonrpc,
+        id,
+        error: {
+          code: -32601,
+          message: `Method not found`,
+          data: {
+            details: method,
+          },
+        },
+      }))
+
+      .defaultToLazy(() => {
+        console.warn(
+          `Coudln't parse the following input ${JSON.stringify(input)}`,
+        )
+        return {
+          jsonrpc,
+          id: (input as any)?.id,
+          error: {
+            code: -32602,
+            message: "invalid params",
+            data: {
+              details: JSON.stringify(input),
+            },
+          },
+        }
+      })
+  }
+}

container-runtime/src/Adapters/Systems/SystemForEmbassy/DockerProcedureContainer.ts

@@ -0,0 +1,93 @@
+import * as fs from "fs/promises"
+import * as cp from "child_process"
+import { Overlay, types as T } from "@start9labs/start-sdk"
+import { promisify } from "util"
+import { DockerProcedure, VolumeId } from "../../../Models/DockerProcedure"
+import { Volume } from "./matchVolume"
+export const exec = promisify(cp.exec)
+export const execFile = promisify(cp.execFile)
+
+export class DockerProcedureContainer {
+  private constructor(readonly overlay: Overlay) {}
+  // static async readonlyOf(data: DockerProcedure) {
+  //   return DockerProcedureContainer.of(data, ["-o", "ro"])
+  // }
+  static async of(
+    effects: T.Effects,
+    data: DockerProcedure,
+    volumes: { [id: VolumeId]: Volume },
+  ) {
+    const overlay = await Overlay.of(effects, data.image)
+
+    if (data.mounts) {
+      const mounts = data.mounts
+      for (const mount in mounts) {
+        const path = mounts[mount].startsWith("/")
+          ? `${overlay.rootfs}${mounts[mount]}`
+          : `${overlay.rootfs}/${mounts[mount]}`
+        await fs.mkdir(path, { recursive: true })
+        const volumeMount = volumes[mount]
+        if (volumeMount.type === "data") {
+          await overlay.mount({ type: "volume", id: mount }, mounts[mount])
+        } else if (volumeMount.type === "assets") {
+          await overlay.mount({ type: "assets", id: mount }, mounts[mount])
+        } else if (volumeMount.type === "certificate") {
+          volumeMount
+          const certChain = await effects.getSslCertificate({
+            packageId: null,
+            hostId: volumeMount["interface-id"],
+            algorithm: null,
+          })
+          const key = await effects.getSslKey({
+            packageId: null,
+            hostId: volumeMount["interface-id"],
+            algorithm: null,
+          })
+          await fs.writeFile(
+            `${path}/${volumeMount["interface-id"]}.cert.pem`,
+            certChain.join("\n"),
+          )
+          await fs.writeFile(
+            `${path}/${volumeMount["interface-id"]}.key.pem`,
+            key,
+          )
+        } else if (volumeMount.type === "pointer") {
+          await effects.mount({
+            location: path,
+            target: {
+              packageId: volumeMount["package-id"],
+              path: volumeMount.path,
+              readonly: volumeMount.readonly,
+              volumeId: volumeMount["volume-id"],
+            },
+          })
+        } else if (volumeMount.type === "backup") {
+          throw new Error("TODO")
+        }
+      }
+    }
+
+    return new DockerProcedureContainer(overlay)
+  }
+
+  async exec(commands: string[]) {
+    try {
+      return await this.overlay.exec(commands)
+    } finally {
+      await this.overlay.destroy()
+    }
+  }
+
+  async execSpawn(commands: string[]) {
+    try {
+      const spawned = await this.overlay.spawn(commands)
+      return spawned
+    } finally {
+      await this.overlay.destroy()
+    }
+  }
+
+  async spawn(commands: string[]): Promise<cp.ChildProcessWithoutNullStreams> {
+    return await this.overlay.spawn(commands)
+  }
+}

container-runtime/src/Adapters/Systems/SystemForEmbassy/MainLoop.ts

@@ -0,0 +1,250 @@
+import { PolyfillEffects } from "./polyfillEffects"
+import { DockerProcedureContainer } from "./DockerProcedureContainer"
+import { SystemForEmbassy } from "."
+import { HostSystemStartOs } from "../../HostSystemStartOs"
+import { util, Daemons, types as T } from "@start9labs/start-sdk"
+import { exec } from "child_process"
+
+const EMBASSY_HEALTH_INTERVAL = 15 * 1000
+const EMBASSY_PROPERTIES_LOOP = 30 * 1000
+/**
+ * We wanted something to represent what the main loop is doing, and
+ * in this case it used to run the properties, health, and the docker/ js main.
+ * Also, this has an ability to clean itself up too if need be.
+ */
+export class MainLoop {
+  private healthLoops:
+    | {
+        name: string
+        interval: NodeJS.Timeout
+      }[]
+    | undefined
+
+  private mainEvent:
+    | Promise<{
+        daemon: T.DaemonReturned
+        wait: Promise<unknown>
+      }>
+    | undefined
+  private propertiesEvent: NodeJS.Timeout | undefined
+  constructor(
+    readonly system: SystemForEmbassy,
+    readonly effects: HostSystemStartOs,
+    readonly runProperties: () => Promise<void>,
+  ) {
+    this.healthLoops = this.constructHealthLoops()
+    this.mainEvent = this.constructMainEvent()
+    this.propertiesEvent = this.constructPropertiesEvent()
+  }
+
+  private async constructMainEvent() {
+    const { system, effects } = this
+    const utils = util.createUtils(effects)
+    const currentCommand: [string, ...string[]] = [
+      system.manifest.main.entrypoint,
+      ...system.manifest.main.args,
+    ]
+
+    await effects.setMainStatus({ status: "running" })
+    const jsMain = (this.system.moduleCode as any)?.jsMain
+    const dockerProcedureContainer = await DockerProcedureContainer.of(
+      effects,
+      this.system.manifest.main,
+      this.system.manifest.volumes,
+    )
+    if (jsMain) {
+      const daemons = Daemons.of({
+        effects,
+        started: async (_) => {},
+        healthReceipts: [],
+      })
+      throw new Error("todo")
+      // return {
+      //   daemon,
+      //   wait: daemon.wait().finally(() => {
+      //     this.clean()
+      //     effects.setMainStatus({ status: "stopped" })
+      //   }),
+      // }
+    }
+    const daemon = await utils.runDaemon(
+      this.system.manifest.main.image,
+      currentCommand,
+      {
+        overlay: dockerProcedureContainer.overlay,
+      },
+    )
+    return {
+      daemon,
+      wait: daemon.wait().finally(() => {
+        this.clean()
+        effects
+          .setMainStatus({ status: "stopped" })
+          .catch((e) => console.error("Could not set the status to stopped"))
+      }),
+    }
+  }
+
+  public async clean(options?: { timeout?: number }) {
+    const { mainEvent, healthLoops, propertiesEvent } = this
+    const main = await mainEvent
+    delete this.mainEvent
+    delete this.healthLoops
+    delete this.propertiesEvent
+    if (mainEvent) await main?.daemon.term()
+    clearInterval(propertiesEvent)
+    if (healthLoops) healthLoops.forEach((x) => clearInterval(x.interval))
+  }
+
+  private constructPropertiesEvent() {
+    const { runProperties } = this
+    return setInterval(() => {
+      runProperties()
+    }, EMBASSY_PROPERTIES_LOOP)
+  }
+
+  private constructHealthLoops() {
+    const { manifest } = this.system
+    const effects = this.effects
+    const start = Date.now()
+    return Object.entries(manifest["health-checks"]).map(
+      ([healthId, value]) => {
+        const interval = setInterval(async () => {
+          const actionProcedure = value
+          const timeChanged = Date.now() - start
+          if (actionProcedure.type === "docker") {
+            const container = await DockerProcedureContainer.of(
+              effects,
+              actionProcedure,
+              manifest.volumes,
+            )
+            const executed = await container.execSpawn([
+              actionProcedure.entrypoint,
+              ...actionProcedure.args,
+              JSON.stringify(timeChanged),
+            ])
+            if (executed.exitCode === 59) {
+              await effects.setHealth({
+                name: healthId,
+                status: "disabled",
+                message:
+                  executed.stderr.toString() || executed.stdout.toString(),
+              })
+              return
+            }
+            if (executed.exitCode === 60) {
+              await effects.setHealth({
+                name: healthId,
+                status: "starting",
+                message:
+                  executed.stderr.toString() || executed.stdout.toString(),
+              })
+              return
+            }
+            if (executed.exitCode === 61) {
+              await effects.setHealth({
+                name: healthId,
+                status: "warning",
+                message:
+                  executed.stderr.toString() || executed.stdout.toString(),
+              })
+              return
+            }
+            const errorMessage = executed.stderr.toString()
+            const message = executed.stdout.toString()
+            if (!!errorMessage) {
+              await effects.setHealth({
+                name: healthId,
+                status: "failure",
+                message: errorMessage,
+              })
+              return
+            }
+            await effects.setHealth({
+              name: healthId,
+              status: "passing",
+              message,
+            })
+            return
+          } else {
+            actionProcedure
+            const moduleCode = await this.system.moduleCode
+            const method = moduleCode.health?.[healthId]
+            if (!method) {
+              await effects.setHealth({
+                name: healthId,
+                status: "failure",
+                message: `Expecting that thejs health check ${healthId} exists`,
+              })
+              return
+            }
+
+            const result = await method(
+              new PolyfillEffects(effects, this.system.manifest),
+              timeChanged,
+            )
+
+            if ("result" in result) {
+              await effects.setHealth({
+                message: null,
+                name: healthId,
+                status: "passing",
+              })
+              return
+            }
+            if ("error" in result) {
+              await effects.setHealth({
+                name: healthId,
+                status: "failure",
+                message: result.error,
+              })
+              return
+            }
+            if (!("error-code" in result)) {
+              await effects.setHealth({
+                name: healthId,
+                status: "failure",
+                message: `Unknown error type ${JSON.stringify(result)}`,
+              })
+              return
+            }
+            const [code, message] = result["error-code"]
+            if (code === 59) {
+              await effects.setHealth({
+                name: healthId,
+                status: "disabled",
+                message,
+              })
+              return
+            }
+            if (code === 60) {
+              await effects.setHealth({
+                name: healthId,
+                status: "starting",
+                message,
+              })
+              return
+            }
+            if (code === 61) {
+              await effects.setHealth({
+                name: healthId,
+                status: "warning",
+                message,
+              })
+              return
+            }
+
+            await effects.setHealth({
+              name: healthId,
+              status: "failure",
+              message: `${result["error-code"][0]}: ${result["error-code"][1]}`,
+            })
+            return
+          }
+        }, EMBASSY_HEALTH_INTERVAL)
+
+        return { name: healthId, interval }
+      },
+    )
+  }
+}

container-runtime/src/Adapters/Systems/SystemForEmbassy/matchManifest.ts

@@ -0,0 +1,119 @@
+import {
+  object,
+  literal,
+  string,
+  array,
+  boolean,
+  dictionary,
+  literals,
+  number,
+  unknown,
+  some,
+  every,
+} from "ts-matches"
+import { matchVolume } from "./matchVolume"
+import { matchDockerProcedure } from "../../../Models/DockerProcedure"
+
+const matchJsProcedure = object(
+  {
+    type: literal("script"),
+    args: array(unknown),
+  },
+  ["args"],
+  {
+    args: [],
+  },
+)
+
+const matchProcedure = some(matchDockerProcedure, matchJsProcedure)
+export type Procedure = typeof matchProcedure._TYPE
+
+const matchAction = object(
+  {
+    name: string,
+    description: string,
+    warning: string,
+    implementation: matchProcedure,
+    "allowed-statuses": array(literals("running", "stopped")),
+    "input-spec": unknown,
+  },
+  ["warning", "input-spec", "input-spec"],
+)
+export const matchManifest = object(
+  {
+    id: string,
+    version: string,
+    main: matchDockerProcedure,
+    assets: object(
+      {
+        assets: string,
+        scripts: string,
+      },
+      ["assets", "scripts"],
+    ),
+    "health-checks": dictionary([
+      string,
+      every(
+        matchProcedure,
+        object({
+          name: string,
+        }),
+      ),
+    ]),
+    config: object({
+      get: matchProcedure,
+      set: matchProcedure,
+    }),
+    properties: matchProcedure,
+    volumes: dictionary([string, matchVolume]),
+    interfaces: dictionary([
+      string,
+      object({
+        name: string,
+        "tor-config": object({}),
+        "lan-config": object({}),
+        ui: boolean,
+        protocols: array(string),
+      }),
+    ]),
+    backup: object({
+      create: matchProcedure,
+      restore: matchProcedure,
+    }),
+    migrations: object({
+      to: dictionary([string, matchProcedure]),
+      from: dictionary([string, matchProcedure]),
+    }),
+    dependencies: dictionary([
+      string,
+      object(
+        {
+          version: string,
+          requirement: some(
+            object({
+              type: literal("opt-in"),
+              how: string,
+            }),
+            object({
+              type: literal("opt-out"),
+              how: string,
+            }),
+            object({
+              type: literal("required"),
+            }),
+          ),
+          description: string,
+          config: object({
+            check: matchProcedure,
+            "auto-configure": matchProcedure,
+          }),
+        },
+        ["description", "config"],
+      ),
+    ]),
+
+    actions: dictionary([string, matchAction]),
+  },
+  ["config", "actions", "properties", "migrations", "dependencies"],
+)
+export type Manifest = typeof matchManifest._TYPE

container-runtime/src/Adapters/Systems/SystemForEmbassy/matchVolume.ts

@@ -0,0 +1,35 @@
+import { object, literal, string, boolean, some } from "ts-matches"
+
+const matchDataVolume = object(
+  {
+    type: literal("data"),
+    readonly: boolean,
+  },
+  ["readonly"],
+)
+const matchAssetVolume = object({
+  type: literal("assets"),
+})
+const matchPointerVolume = object({
+  type: literal("pointer"),
+  "package-id": string,
+  "volume-id": string,
+  path: string,
+  readonly: boolean,
+})
+const matchCertificateVolume = object({
+  type: literal("certificate"),
+  "interface-id": string,
+})
+const matchBackupVolume = object({
+  type: literal("backup"),
+  readonly: boolean,
+})
+export const matchVolume = some(
+  matchDataVolume,
+  matchAssetVolume,
+  matchPointerVolume,
+  matchCertificateVolume,
+  matchBackupVolume,
+)
+export type Volume = typeof matchVolume._TYPE

container-runtime/src/Adapters/Systems/SystemForEmbassy/oldEmbassyTypes.ts

@@ -0,0 +1,482 @@
+// deno-lint-ignore no-namespace
+export type ExpectedExports = {
+  version: 2
+  /** Set configuration is called after we have modified and saved the configuration in the embassy ui. Use this to make a file for the docker to read from for configuration.  */
+  setConfig: (effects: Effects, input: Config) => Promise<ResultType<SetResult>>
+  /** Get configuration returns a shape that describes the format that the embassy ui will generate, and later send to the set config  */
+  getConfig: (effects: Effects) => Promise<ResultType<ConfigRes>>
+  /** These are how we make sure the our dependency configurations are valid and if not how to fix them. */
+  dependencies: Dependencies
+  /** For backing up service data though the embassyOS UI */
+  createBackup: (effects: Effects) => Promise<ResultType<unknown>>
+  /** For restoring service data that was previously backed up using the embassyOS UI create backup flow. Backup restores are also triggered via the embassyOS UI, or doing a system restore flow during setup. */
+  restoreBackup: (effects: Effects) => Promise<ResultType<unknown>>
+  /**  Properties are used to get values from the docker, like a username + password, what ports we are hosting from */
+  properties: (effects: Effects) => Promise<ResultType<Properties>>
+  health: {
+    /** Should be the health check id */
+    [id: string]: (
+      effects: Effects,
+      dateMs: number,
+    ) => Promise<ResultType<unknown>>
+  }
+  migration: (
+    effects: Effects,
+    version: string,
+    ...args: unknown[]
+  ) => Promise<ResultType<MigrationRes>>
+  action: {
+    [id: string]: (
+      effects: Effects,
+      config?: Config,
+    ) => Promise<ResultType<ActionResult>>
+  }
+
+  /**
+   * This is the entrypoint for the main container. Used to start up something like the service that the
+   * package represents, like running a bitcoind in a bitcoind-wrapper.
+   */
+  main: (effects: Effects) => Promise<ResultType<unknown>>
+}
+
+/** Used to reach out from the pure js runtime */
+export type Effects = {
+  /** Usable when not sandboxed */
+  writeFile(input: {
+    path: string
+    volumeId: string
+    toWrite: string
+  }): Promise<void>
+  readFile(input: { volumeId: string; path: string }): Promise<string>
+  metadata(input: { volumeId: string; path: string }): Promise<Metadata>
+  /** Create a directory. Usable when not sandboxed */
+  createDir(input: { volumeId: string; path: string }): Promise<string>
+
+  readDir(input: { volumeId: string; path: string }): Promise<string[]>
+  /** Remove a directory. Usable when not sandboxed */
+  removeDir(input: { volumeId: string; path: string }): Promise<string>
+  removeFile(input: { volumeId: string; path: string }): Promise<void>
+
+  /** Write a json file into an object. Usable when not sandboxed */
+  writeJsonFile(input: {
+    volumeId: string
+    path: string
+    toWrite: Record<string, unknown>
+  }): Promise<void>
+
+  /** Read a json file into an object */
+  readJsonFile(input: {
+    volumeId: string
+    path: string
+  }): Promise<Record<string, unknown>>
+
+  runCommand(input: {
+    command: string
+    args?: string[]
+    timeoutMillis?: number
+  }): Promise<ResultType<string>>
+  runDaemon(input: { command: string; args?: string[] }): {
+    wait(): Promise<ResultType<string>>
+    term(): Promise<void>
+  }
+
+  chown(input: { volumeId: string; path: string; uid: string }): Promise<null>
+  chmod(input: { volumeId: string; path: string; mode: string }): Promise<null>
+
+  sleep(timeMs: number): Promise<null>
+
+  /** Log at the trace level */
+  trace(whatToPrint: string): void
+  /** Log at the warn level */
+  warn(whatToPrint: string): void
+  /** Log at the error level */
+  error(whatToPrint: string): void
+  /** Log at the debug level */
+  debug(whatToPrint: string): void
+  /** Log at the info level */
+  info(whatToPrint: string): void
+
+  /** Sandbox mode lets us read but not write */
+  is_sandboxed(): boolean
+
+  exists(input: { volumeId: string; path: string }): Promise<boolean>
+  bindLocal(options: {
+    internalPort: number
+    name: string
+    externalPort: number
+  }): Promise<string>
+  bindTor(options: {
+    internalPort: number
+    name: string
+    externalPort: number
+  }): Promise<string>
+
+  fetch(
+    url: string,
+    options?: {
+      method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "PATCH"
+      headers?: Record<string, string>
+      body?: string
+    },
+  ): Promise<{
+    method: string
+    ok: boolean
+    status: number
+    headers: Record<string, string>
+    body?: string | null
+    /// Returns the body as a string
+    text(): Promise<string>
+    /// Returns the body as a json
+    json(): Promise<unknown>
+  }>
+
+  runRsync(options: {
+    srcVolume: string
+    dstVolume: string
+    srcPath: string
+    dstPath: string
+    // rsync options: https://linux.die.net/man/1/rsync
+    options: BackupOptions
+  }): {
+    id: () => Promise<string>
+    wait: () => Promise<null>
+    progress: () => Promise<number>
+  }
+}
+
+// rsync options: https://linux.die.net/man/1/rsync
+export type BackupOptions = {
+  delete: boolean
+  force: boolean
+  ignoreExisting: boolean
+  exclude: string[]
+}
+export type Metadata = {
+  fileType: string
+  isDir: boolean
+  isFile: boolean
+  isSymlink: boolean
+  len: number
+  modified?: Date
+  accessed?: Date
+  created?: Date
+  readonly: boolean
+  uid: number
+  gid: number
+  mode: number
+}
+
+export type MigrationRes = {
+  configured: boolean
+}
+
+export type ActionResult = {
+  version: "0"
+  message: string
+  value?: string
+  copyable: boolean
+  qr: boolean
+}
+
+export type ConfigRes = {
+  /** This should be the previous config, that way during set config we start with the previous */
+  config?: Config
+  /** Shape that is describing the form in the ui */
+  spec: ConfigSpec
+}
+export type Config = {
+  [propertyName: string]: unknown
+}
+
+export type ConfigSpec = {
+  /** Given a config value, define what it should render with the following spec */
+  [configValue: string]: ValueSpecAny
+}
+export type WithDefault<T, Default> = T & {
+  default: Default
+}
+export type WithNullableDefault<T, Default> = T & {
+  default?: Default
+}
+
+export type WithDescription<T> = T & {
+  description?: string
+  name: string
+  warning?: string
+}
+
+export type WithOptionalDescription<T> = T & {
+  /** @deprecated - optional only for backwards compatibility */
+  description?: string
+  /** @deprecated - optional only for backwards compatibility */
+  name?: string
+  warning?: string
+}
+
+export type ListSpec<T> = {
+  spec: T
+  range: string
+}
+
+export type Tag<T extends string, V> = V & {
+  type: T
+}
+
+export type Subtype<T extends string, V> = V & {
+  subtype: T
+}
+
+export type Target<T extends string, V> = V & {
+  target: T
+}
+
+export type UniqueBy =
+  | {
+      any: UniqueBy[]
+    }
+  | string
+  | null
+
+export type WithNullable<T> = T & {
+  nullable: boolean
+}
+export type DefaultString =
+  | string
+  | {
+      /** The chars available for the random generation */
+      charset?: string
+      /** Length that we generate to */
+      len: number
+    }
+
+export type ValueSpecString = // deno-lint-ignore ban-types
+  (
+    | {}
+    | {
+        pattern: string
+        "pattern-description": string
+      }
+  ) & {
+    copyable?: boolean
+    masked?: boolean
+    placeholder?: string
+  }
+export type ValueSpecNumber = {
+  /** Something like [3,6] or [0, *) */
+  range?: string
+  integral?: boolean
+  /** Used a description of the units */
+  units?: string
+  placeholder?: number
+}
+export type ValueSpecBoolean = Record<string, unknown>
+export type ValueSpecAny =
+  | Tag<"boolean", WithDescription<WithDefault<ValueSpecBoolean, boolean>>>
+  | Tag<
+      "string",
+      WithDescription<
+        WithNullableDefault<WithNullable<ValueSpecString>, DefaultString>
+      >
+    >
+  | Tag<
+      "number",
+      WithDescription<
+        WithNullableDefault<WithNullable<ValueSpecNumber>, number>
+      >
+    >
+  | Tag<
+      "enum",
+      WithDescription<
+        WithDefault<
+          {
+            values: readonly string[] | string[]
+            "value-names": {
+              [key: string]: string
+            }
+          },
+          string
+        >
+      >
+    >
+  | Tag<"list", ValueSpecList>
+  | Tag<"object", WithDescription<WithNullableDefault<ValueSpecObject, Config>>>
+  | Tag<"union", WithOptionalDescription<WithDefault<ValueSpecUnion, string>>>
+  | Tag<
+      "pointer",
+      WithDescription<
+        | Subtype<
+            "package",
+            | Target<
+                "tor-key",
+                {
+                  "package-id": string
+                  interface: string
+                }
+              >
+            | Target<
+                "tor-address",
+                {
+                  "package-id": string
+                  interface: string
+                }
+              >
+            | Target<
+                "lan-address",
+                {
+                  "package-id": string
+                  interface: string
+                }
+              >
+            | Target<
+                "config",
+                {
+                  "package-id": string
+                  selector: string
+                  multi: boolean
+                }
+              >
+          >
+        | Subtype<"system", Record<string, unknown>>
+      >
+    >
+export type ValueSpecUnion = {
+  /** What tag for the specification, for tag unions */
+  tag: {
+    id: string
+    name: string
+    description?: string
+    "variant-names": {
+      [key: string]: string
+    }
+  }
+  /** The possible enum values */
+  variants: {
+    [key: string]: ConfigSpec
+  }
+  "display-as"?: string
+  "unique-by"?: UniqueBy
+}
+export type ValueSpecObject = {
+  spec: ConfigSpec
+  "display-as"?: string
+  "unique-by"?: UniqueBy
+}
+export type ValueSpecList =
+  | Subtype<
+      "boolean",
+      WithDescription<WithDefault<ListSpec<ValueSpecBoolean>, boolean[]>>
+    >
+  | Subtype<
+      "string",
+      WithDescription<WithDefault<ListSpec<ValueSpecString>, string[]>>
+    >
+  | Subtype<
+      "number",
+      WithDescription<WithDefault<ListSpec<ValueSpecNumber>, number[]>>
+    >
+  | Subtype<
+      "enum",
+      WithDescription<WithDefault<ListSpec<ValueSpecEnum>, string[]>>
+    >
+  | Subtype<
+      "object",
+      WithDescription<
+        WithNullableDefault<
+          ListSpec<ValueSpecObject>,
+          Record<string, unknown>[]
+        >
+      >
+    >
+  | Subtype<
+      "union",
+      WithDescription<WithDefault<ListSpec<ValueSpecUnion>, string[]>>
+    >
+export type ValueSpecEnum = {
+  values: string[]
+  "value-names": { [key: string]: string }
+}
+
+export type SetResult = {
+  /** These are the unix process signals */
+  signal:
+    | "SIGTERM"
+    | "SIGHUP"
+    | "SIGINT"
+    | "SIGQUIT"
+    | "SIGILL"
+    | "SIGTRAP"
+    | "SIGABRT"
+    | "SIGBUS"
+    | "SIGFPE"
+    | "SIGKILL"
+    | "SIGUSR1"
+    | "SIGSEGV"
+    | "SIGUSR2"
+    | "SIGPIPE"
+    | "SIGALRM"
+    | "SIGSTKFLT"
+    | "SIGCHLD"
+    | "SIGCONT"
+    | "SIGSTOP"
+    | "SIGTSTP"
+    | "SIGTTIN"
+    | "SIGTTOU"
+    | "SIGURG"
+    | "SIGXCPU"
+    | "SIGXFSZ"
+    | "SIGVTALRM"
+    | "SIGPROF"
+    | "SIGWINCH"
+    | "SIGIO"
+    | "SIGPWR"
+    | "SIGSYS"
+    | "SIGEMT"
+    | "SIGINFO"
+  "depends-on": DependsOn
+}
+
+export type DependsOn = {
+  [packageId: string]: string[]
+}
+
+export type KnownError =
+  | { error: string }
+  | {
+      "error-code": [number, string] | readonly [number, string]
+    }
+export type ResultType<T> = KnownError | { result: T }
+
+export type PackagePropertiesV2 = {
+  [name: string]: PackagePropertyObject | PackagePropertyString
+}
+export type PackagePropertyString = {
+  type: "string"
+  description?: string
+  value: string
+  /** Let's the ui make this copyable button */
+  copyable?: boolean
+  /** Let the ui create a qr for this field */
+  qr?: boolean
+  /** Hiding the value unless toggled off for field */
+  masked?: boolean
+}
+export type PackagePropertyObject = {
+  value: PackagePropertiesV2
+  type: "object"
+  description: string
+}
+
+export type Properties = {
+  version: 2
+  data: PackagePropertiesV2
+}
+
+export type Dependencies = {
+  /** Id is the id of the package, should be the same as the manifest */
+  [id: string]: {
+    /** Checks are called to make sure that our dependency is in the correct shape. If a known error is returned we know that the dependency needs modification */
+    check(effects: Effects, input: Config): Promise<ResultType<void | null>>
+    /** This is called after we know that the dependency package needs a new configuration, this would be a transform for defaults */
+    autoConfigure(effects: Effects, input: Config): Promise<ResultType<Config>>
+  }
+}

container-runtime/src/Adapters/Systems/SystemForEmbassy/polyfillEffects.ts

@@ -0,0 +1,215 @@
+import * as fs from "fs/promises"
+import * as oet from "./oldEmbassyTypes"
+import { Volume } from "../../../Models/Volume"
+import * as child_process from "child_process"
+import { promisify } from "util"
+import { util, Utils } from "@start9labs/start-sdk"
+import { Manifest } from "./matchManifest"
+import { HostSystemStartOs } from "../../HostSystemStartOs"
+import "isomorphic-fetch"
+
+const { createUtils } = util
+
+const execFile = promisify(child_process.execFile)
+
+export class PolyfillEffects implements oet.Effects {
+  private utils: Utils<any, any>
+  constructor(
+    readonly effects: HostSystemStartOs,
+    private manifest: Manifest,
+  ) {
+    this.utils = createUtils(effects as any)
+  }
+  async writeFile(input: {
+    path: string
+    volumeId: string
+    toWrite: string
+  }): Promise<void> {
+    await fs.writeFile(
+      new Volume(input.volumeId, input.path).path,
+      input.toWrite,
+    )
+  }
+  async readFile(input: { volumeId: string; path: string }): Promise<string> {
+    return (
+      await fs.readFile(new Volume(input.volumeId, input.path).path)
+    ).toString()
+  }
+  async metadata(input: {
+    volumeId: string
+    path: string
+  }): Promise<oet.Metadata> {
+    const stats = await fs.stat(new Volume(input.volumeId, input.path).path)
+    return {
+      fileType: stats.isFile() ? "file" : "directory",
+      gid: stats.gid,
+      uid: stats.uid,
+      mode: stats.mode,
+      isDir: stats.isDirectory(),
+      isFile: stats.isFile(),
+      isSymlink: stats.isSymbolicLink(),
+      len: stats.size,
+      readonly: (stats.mode & 0o200) > 0,
+    }
+  }
+  async createDir(input: { volumeId: string; path: string }): Promise<string> {
+    const path = new Volume(input.volumeId, input.path).path
+    await fs.mkdir(path, { recursive: true })
+    return path
+  }
+  async readDir(input: { volumeId: string; path: string }): Promise<string[]> {
+    return fs.readdir(new Volume(input.volumeId, input.path).path)
+  }
+  async removeDir(input: { volumeId: string; path: string }): Promise<string> {
+    const path = new Volume(input.volumeId, input.path).path
+    await fs.rmdir(new Volume(input.volumeId, input.path).path, {
+      recursive: true,
+    })
+    return path
+  }
+  removeFile(input: { volumeId: string; path: string }): Promise<void> {
+    return fs.rm(new Volume(input.volumeId, input.path).path)
+  }
+  async writeJsonFile(input: {
+    volumeId: string
+    path: string
+    toWrite: Record<string, unknown>
+  }): Promise<void> {
+    await fs.writeFile(
+      new Volume(input.volumeId, input.path).path,
+      JSON.stringify(input.toWrite),
+    )
+  }
+  async readJsonFile(input: {
+    volumeId: string
+    path: string
+  }): Promise<Record<string, unknown>> {
+    return JSON.parse(
+      (
+        await fs.readFile(new Volume(input.volumeId, input.path).path)
+      ).toString(),
+    )
+  }
+  runCommand({
+    command,
+    args,
+    timeoutMillis,
+  }: {
+    command: string
+    args?: string[] | undefined
+    timeoutMillis?: number | undefined
+  }): Promise<oet.ResultType<string>> {
+    return this.utils
+      .runCommand(this.manifest.main.image, [command, ...(args || [])], {})
+      .then((x) => ({
+        stderr: x.stderr.toString(),
+        stdout: x.stdout.toString(),
+      }))
+      .then((x) => (!!x.stderr ? { error: x.stderr } : { result: x.stdout }))
+  }
+  runDaemon(input: { command: string; args?: string[] | undefined }): {
+    wait(): Promise<oet.ResultType<string>>
+    term(): Promise<void>
+  } {
+    throw new Error("Method not implemented.")
+  }
+  chown(input: { volumeId: string; path: string; uid: string }): Promise<null> {
+    throw new Error("Method not implemented.")
+  }
+  chmod(input: {
+    volumeId: string
+    path: string
+    mode: string
+  }): Promise<null> {
+    throw new Error("Method not implemented.")
+  }
+  sleep(timeMs: number): Promise<null> {
+    return new Promise((resolve) => setTimeout(resolve, timeMs))
+  }
+  trace(whatToPrint: string): void {
+    console.trace(whatToPrint)
+  }
+  warn(whatToPrint: string): void {
+    console.warn(whatToPrint)
+  }
+  error(whatToPrint: string): void {
+    console.error(whatToPrint)
+  }
+  debug(whatToPrint: string): void {
+    console.debug(whatToPrint)
+  }
+  info(whatToPrint: string): void {
+    console.log(false)
+  }
+  is_sandboxed(): boolean {
+    return false
+  }
+  exists(input: { volumeId: string; path: string }): Promise<boolean> {
+    return this.metadata(input)
+      .then(() => true)
+      .catch(() => false)
+  }
+  bindLocal(options: {
+    internalPort: number
+    name: string
+    externalPort: number
+  }): Promise<string> {
+    throw new Error("Method not implemented.")
+  }
+  bindTor(options: {
+    internalPort: number
+    name: string
+    externalPort: number
+  }): Promise<string> {
+    throw new Error("Method not implemented.")
+  }
+  async fetch(
+    url: string,
+    options?:
+      | {
+          method?:
+            | "GET"
+            | "POST"
+            | "PUT"
+            | "DELETE"
+            | "HEAD"
+            | "PATCH"
+            | undefined
+          headers?: Record<string, string> | undefined
+          body?: string | undefined
+        }
+      | undefined,
+  ): Promise<{
+    method: string
+    ok: boolean
+    status: number
+    headers: Record<string, string>
+    body?: string | null | undefined
+    text(): Promise<string>
+    json(): Promise<unknown>
+  }> {
+    const fetched = await fetch(url, options)
+    return {
+      method: fetched.type,
+      ok: fetched.ok,
+      status: fetched.status,
+      headers: Object.fromEntries(fetched.headers.entries()),
+      body: await fetched.text(),
+      text: () => fetched.text(),
+      json: () => fetched.json(),
+    }
+  }
+  runRsync(options: {
+    srcVolume: string
+    dstVolume: string
+    srcPath: string
+    dstPath: string
+    options: oet.BackupOptions
+  }): {
+    id: () => Promise<string>
+    wait: () => Promise<null>
+    progress: () => Promise<number>
+  } {
+    throw new Error("Method not implemented.")
+  }
+}

container-runtime/src/Adapters/Systems/SystemForStartOs.ts

@@ -0,0 +1,152 @@
+import { ExecuteResult, System } from "../../Interfaces/System"
+import { unNestPath } from "../../Models/JsonPath"
+import { string } from "ts-matches"
+import { HostSystemStartOs } from "../HostSystemStartOs"
+import { Effects } from "../../Models/Effects"
+import { RpcResult } from "../RpcListener"
+import { duration } from "../../Models/Duration"
+const LOCATION = "/usr/lib/startos/package/startos"
+export class SystemForStartOs implements System {
+  private onTerm: (() => Promise<void>) | undefined
+  static of() {
+    return new SystemForStartOs()
+  }
+  constructor() {}
+  async execute(
+    effects: HostSystemStartOs,
+    options: {
+      procedure:
+        | "/init"
+        | "/uninit"
+        | "/main/start"
+        | "/main/stop"
+        | "/config/set"
+        | "/config/get"
+        | "/backup/create"
+        | "/backup/restore"
+        | "/actions/metadata"
+        | `/actions/${string}/get`
+        | `/actions/${string}/run`
+        | `/dependencies/${string}/query`
+        | `/dependencies/${string}/update`
+      input: unknown
+      timeout?: number | undefined
+    },
+  ): Promise<RpcResult> {
+    return { result: await this._execute(effects, options) }
+  }
+  async _execute(
+    effects: Effects,
+    options: {
+      procedure:
+        | "/init"
+        | "/uninit"
+        | "/main/start"
+        | "/main/stop"
+        | "/config/set"
+        | "/config/get"
+        | "/backup/create"
+        | "/backup/restore"
+        | "/actions/metadata"
+        | `/actions/${string}/get`
+        | `/actions/${string}/run`
+        | `/dependencies/${string}/query`
+        | `/dependencies/${string}/update`
+      input: unknown
+      timeout?: number | undefined
+    },
+  ): Promise<unknown> {
+    switch (options.procedure) {
+      case "/init": {
+        const path = `${LOCATION}/procedures/init`
+        const procedure: any = await import(path).catch(() => require(path))
+        const previousVersion = string.optional().unsafeCast(options)
+        return procedure.init({ effects, previousVersion })
+      }
+      case "/uninit": {
+        const path = `${LOCATION}/procedures/init`
+        const procedure: any = await import(path).catch(() => require(path))
+        const nextVersion = string.optional().unsafeCast(options)
+        return procedure.uninit({ effects, nextVersion })
+      }
+      case "/main/start": {
+        const path = `${LOCATION}/procedures/main`
+        const procedure: any = await import(path).catch(() => require(path))
+        const started = async (onTerm: () => Promise<void>) => {
+          await effects.setMainStatus({ status: "running" })
+          if (this.onTerm) await this.onTerm()
+          this.onTerm = onTerm
+        }
+        return procedure.main({ effects, started })
+      }
+      case "/main/stop": {
+        await effects.setMainStatus({ status: "stopped" })
+        if (this.onTerm) await this.onTerm()
+        delete this.onTerm
+        return duration(30, "s")
+      }
+      case "/config/set": {
+        const path = `${LOCATION}/procedures/config`
+        const procedure: any = await import(path).catch(() => require(path))
+        const input = options.input
+        return procedure.setConfig({ effects, input })
+      }
+      case "/config/get": {
+        const path = `${LOCATION}/procedures/config`
+        const procedure: any = await import(path).catch(() => require(path))
+        return procedure.getConfig({ effects })
+      }
+      case "/backup/create":
+      case "/backup/restore":
+        throw new Error("this should be called with the init/unit")
+      case "/actions/metadata": {
+        const path = `${LOCATION}/procedures/actions`
+        const procedure: any = await import(path).catch(() => require(path))
+        return procedure.actionsMetadata({ effects })
+      }
+      default:
+        const procedures = unNestPath(options.procedure)
+        const id = procedures[2]
+        switch (true) {
+          case procedures[1] === "actions" && procedures[3] === "get": {
+            const path = `${LOCATION}/procedures/actions`
+            const action: any = (await import(path).catch(() => require(path)))
+              .actions[id]
+            if (!action) throw new Error(`Action ${id} not found`)
+            return action.get({ effects })
+          }
+          case procedures[1] === "actions" && procedures[3] === "run": {
+            const path = `${LOCATION}/procedures/actions`
+            const action: any = (await import(path).catch(() => require(path)))
+              .actions[id]
+            if (!action) throw new Error(`Action ${id} not found`)
+            const input = options.input
+            return action.run({ effects, input })
+          }
+          case procedures[1] === "dependencies" && procedures[3] === "query": {
+            const path = `${LOCATION}/procedures/dependencies`
+            const dependencyConfig: any = (
+              await import(path).catch(() => require(path))
+            ).dependencyConfig[id]
+            if (!dependencyConfig)
+              throw new Error(`dependencyConfig ${id} not found`)
+            const localConfig = options.input
+            return dependencyConfig.query({ effects, localConfig })
+          }
+          case procedures[1] === "dependencies" && procedures[3] === "update": {
+            const path = `${LOCATION}/procedures/dependencies`
+            const dependencyConfig: any = (
+              await import(path).catch(() => require(path))
+            ).dependencyConfig[id]
+            if (!dependencyConfig)
+              throw new Error(`dependencyConfig ${id} not found`)
+            return dependencyConfig.update(options.input)
+          }
+        }
+    }
+    throw new Error("Method not implemented.")
+  }
+  exit(effects: Effects): Promise<void> {
+    throw new Error("Method not implemented.")
+  }
+}

container-runtime/src/Adapters/Systems/index.ts

@@ -0,0 +1,6 @@
+import { System } from "../../Interfaces/System"
+import { SystemForEmbassy } from "./SystemForEmbassy"
+import { SystemForStartOs } from "./SystemForStartOs"
+export async function getSystem(): Promise<System> {
+  return SystemForEmbassy.of()
+}

container-runtime/src/Interfaces/AllGetDependencies.ts

@@ -0,0 +1,6 @@
+import { GetDependency } from "./GetDependency"
+import { System } from "./System"
+import { GetHostSystem, HostSystem } from "./HostSystem"
+
+export type AllGetDependencies = GetDependency<"system", Promise<System>> &
+  GetDependency<"hostSystem", GetHostSystem>

container-runtime/src/Interfaces/GetDependency.ts

@@ -0,0 +1,3 @@
+export type GetDependency<K extends string, T> = {
+  [OtherK in K]: () => T
+}

container-runtime/src/Interfaces/HostSystem.ts

@@ -0,0 +1,7 @@
+import { types as T } from "@start9labs/start-sdk"
+
+import { CallbackHolder } from "../Models/CallbackHolder"
+import { Effects } from "../Models/Effects"
+
+export type HostSystem = Effects
+export type GetHostSystem = (callbackHolder: CallbackHolder) => HostSystem

container-runtime/src/Interfaces/System.ts

@@ -0,0 +1,32 @@
+import { types as T } from "@start9labs/start-sdk"
+import { JsonPath } from "../Models/JsonPath"
+import { HostSystemStartOs } from "../Adapters/HostSystemStartOs"
+import { RpcResult } from "../Adapters/RpcListener"
+export type ExecuteResult =
+  | { ok: unknown }
+  | { err: { code: number; message: string } }
+export interface System {
+  // init(effects: Effects): Promise<void>
+  // exit(effects: Effects): Promise<void>
+  // start(effects: Effects): Promise<void>
+  // stop(effects: Effects, options: { timeout: number, signal?: number }): Promise<void>
+
+  execute(
+    effects: T.Effects,
+    options: {
+      procedure: JsonPath
+      input: unknown
+      timeout?: number
+    },
+  ): Promise<RpcResult>
+  // sandbox(
+  //   effects: Effects,
+  //   options: {
+  //     procedure: JsonPath
+  //     input: unknown
+  //     timeout?: number
+  //   },
+  // ): Promise<unknown>
+
+  exit(effects: T.Effects): Promise<void>
+}

container-runtime/src/Models/CallbackHolder.ts

@@ -0,0 +1,20 @@
+export class CallbackHolder {
+  constructor() {}
+  private root = (Math.random() + 1).toString(36).substring(7)
+  private inc = 0
+  private callbacks = new Map<string, Function>()
+  private newId() {
+    return this.root + (this.inc++).toString(36)
+  }
+  addCallback(callback: Function) {
+    const id = this.newId()
+    this.callbacks.set(id, callback)
+    return id
+  }
+  callCallback(index: string, args: any[]): Promise<unknown> {
+    const callback = this.callbacks.get(index)
+    if (!callback) throw new Error(`Callback ${index} does not exist`)
+    this.callbacks.delete(index)
+    return Promise.resolve().then(() => callback(...args))
+  }
+}

container-runtime/src/Models/DockerProcedure.ts

@@ -0,0 +1,45 @@
+import {
+  object,
+  literal,
+  string,
+  boolean,
+  array,
+  dictionary,
+  literals,
+  number,
+  Parser,
+} from "ts-matches"
+
+const VolumeId = string
+const Path = string
+
+export type VolumeId = string
+export type Path = string
+export const matchDockerProcedure = object(
+  {
+    type: literal("docker"),
+    image: string,
+    system: boolean,
+    entrypoint: string,
+    args: array(string),
+    mounts: dictionary([VolumeId, Path]),
+    "io-format": literals(
+      "json",
+      "json-pretty",
+      "yaml",
+      "cbor",
+      "toml",
+      "toml-pretty",
+    ),
+    "sigterm-timeout": number,
+    inject: boolean,
+  },
+  ["io-format", "sigterm-timeout", "system", "args", "inject", "mounts"],
+  {
+    "sigterm-timeout": 30,
+    inject: false,
+    args: [],
+  },
+)
+
+export type DockerProcedure = typeof matchDockerProcedure._TYPE

container-runtime/src/Models/Duration.ts

@@ -0,0 +1,6 @@
+export type TimeUnit = "d" | "h" | "s" | "ms"
+export type Duration = `${number}${TimeUnit}`
+
+export function duration(timeValue: number, timeUnit: TimeUnit = "s") {
+  return `${timeValue}${timeUnit}` as Duration
+}

container-runtime/src/Models/Effects.ts

@@ -0,0 +1,5 @@
+import { types as T } from "@start9labs/start-sdk"
+
+export type Effects = T.Effects & {
+  setMainStatus(o: { status: "running" | "stopped" }): Promise<void>
+}

container-runtime/src/Models/JsonPath.ts

@@ -0,0 +1,42 @@
+import { literals, some, string } from "ts-matches"
+
+type NestedPath<A extends string, B extends string> = `/${A}/${string}/${B}`
+type NestedPaths =
+  | NestedPath<"actions", "run" | "get">
+  | NestedPath<"dependencies", "query" | "update">
+// prettier-ignore
+type UnNestPaths<A> = 
+  A extends `${infer A}/${infer B}` ? [...UnNestPaths<A>, ... UnNestPaths<B>] : 
+  [A]
+
+export function unNestPath<A extends string>(a: A): UnNestPaths<A> {
+  return a.split("/") as UnNestPaths<A>
+}
+function isNestedPath(path: string): path is NestedPaths {
+  const paths = path.split("/")
+  if (paths.length !== 4) return false
+  if (paths[1] === "action" && (paths[3] === "run" || paths[3] === "get"))
+    return true
+  if (
+    paths[1] === "dependencyConfig" &&
+    (paths[3] === "query" || paths[3] === "update")
+  )
+    return true
+  return false
+}
+export const jsonPath = some(
+  literals(
+    "/init",
+    "/uninit",
+    "/main/start",
+    "/main/stop",
+    "/config/set",
+    "/config/get",
+    "/backup/create",
+    "/backup/restore",
+    "/actions/metadata",
+  ),
+  string.refine(isNestedPath, "isNestedPath"),
+)
+
+export type JsonPath = typeof jsonPath._TYPE

container-runtime/src/Models/Volume.ts

@@ -0,0 +1,19 @@
+import * as fs from "node:fs/promises"
+
+export class Volume {
+  readonly path: string
+  constructor(
+    readonly volumeId: string,
+    _path = "",
+  ) {
+    const path = (this.path = `/media/startos/volumes/${volumeId}${
+      !_path ? "" : `/${_path}`
+    }`)
+  }
+  async exists() {
+    return fs.stat(this.path).then(
+      () => true,
+      () => false,
+    )
+  }
+}

container-runtime/src/index.ts

@@ -0,0 +1,44 @@
+import { RpcListener } from "./Adapters/RpcListener"
+import { SystemForEmbassy } from "./Adapters/Systems/SystemForEmbassy"
+import { HostSystemStartOs } from "./Adapters/HostSystemStartOs"
+import { AllGetDependencies } from "./Interfaces/AllGetDependencies"
+import { getSystem } from "./Adapters/Systems"
+
+const getDependencies: AllGetDependencies = {
+  system: getSystem,
+  hostSystem: () => HostSystemStartOs.of,
+}
+
+new RpcListener(getDependencies)
+
+/**
+
+So, this is going to be sent into a running comtainer along with any of the other node modules that are going to be needed and used.
+
+Once the container is started, we will go into a loading/ await state.
+This is the init system, and it will always be running, and it will be waiting for a command to be sent to it.
+
+Each command will be a stopable promise. And an example is going to be something like an action/ main/ or just a query into the types.
+
+A command will be sent an object which are the effects, and the effects will be things like the file system, the network, the process, and the os.
+
+
+ */
+// So OS Adapter
+// ==============
+
+/**
+* Why: So when the we call from the os we enter or leave here? 
+    
+ */
+
+/**
+Command: This is a command that the 
+
+There are 
+ */
+
+/**
+TODO:
+Should I seperate those adapter in/out?
+ */

container-runtime/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "include": [
+    "./**/*.mjs",
+    "./**/*.js",
+    "src/Adapters/RpcListener.ts",
+    "src/index.ts",
+    "effects.ts"
+  ],
+  "exclude": ["dist"],
+  "inputs": ["./src/index.ts"],
+  "compilerOptions": {
+    "module": "Node16",
+    "strict": true,
+    "outDir": "dist",
+    "preserveConstEnums": true,
+    "sourceMap": true,
+    "target": "ES2022",
+    "pretty": true,
+    "declaration": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "types": ["node"],
+    "moduleResolution": "Node16",
+    "skipLibCheck": true
+  },
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  }
+}

container-runtime/update-image.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+set -e
+
+
+
+if mountpoint tmp/combined; then sudo umount tmp/combined; fi
+if mountpoint tmp/lower; then sudo umount tmp/lower; fi
+mkdir -p tmp/lower tmp/upper tmp/work tmp/combined
+sudo mount alpine.squashfs tmp/lower
+sudo mount -t overlay -olowerdir=tmp/lower,upperdir=tmp/upper,workdir=tmp/work overlay tmp/combined
+
+QEMU=
+if [ "$ARCH" != "$(uname -m)" ]; then
+    QEMU=/usr/bin/qemu-${ARCH}-static
+    sudo cp $(which qemu-$ARCH-static) tmp/combined${QEMU}
+fi
+
+echo "nameserver 8.8.8.8" | sudo tee tmp/combined/etc/resolv.conf # TODO - delegate to host resolver?
+sudo chroot tmp/combined $QEMU /sbin/apk add nodejs
+sudo mkdir -p tmp/combined/usr/lib/startos/
+sudo rsync -a --copy-unsafe-links dist/ tmp/combined/usr/lib/startos/init/
+sudo cp containerRuntime.rc tmp/combined/etc/init.d/containerRuntime
+sudo cp ../core/target/$ARCH-unknown-linux-musl/release/containerbox tmp/combined/usr/bin/start-cli
+sudo chmod +x tmp/combined/etc/init.d/containerRuntime
+sudo chroot tmp/combined $QEMU /sbin/rc-update add containerRuntime default
+
+if [ -n "$QEMU" ]; then
+    sudo rm tmp/combined${QEMU}
+fi
+
+sudo truncate -s 0 tmp/combined/etc/resolv.conf
+sudo chown -R 0:0 tmp/combined
+rm -f ../build/lib/container-runtime/rootfs.squashfs
+mkdir -p ../build/lib/container-runtime
+sudo mksquashfs tmp/combined ../build/lib/container-runtime/rootfs.squashfs
+sudo umount tmp/combined
+sudo umount tmp/lower
+sudo rm -rf tmp