Merge branch 'integration/new-container-runtime' of github.com:Start9Labs/start-os into integration/new-container-runtime

2026-03-30 04:01:58 +00:00 · 2024-03-18 15:15:55 -06:00
parent 3c6c0b253d 5f40fd6038
commit 2ffa632796
111 changed files with 2332 additions and 2042 deletions
--- a/sdk/lib/StartSdk.ts
+++ b/sdk/lib/StartSdk.ts
@@ -19,9 +19,14 @@ import {
  BackupOptions,
  DeepPartial,
  MaybePromise,
+  ServiceInterfaceId,
+  PackageId,
+  EnsureStorePath,
+  ExtractStore,
+  DaemonReturned,
+  ValidIfNoStupidEscape,
 } from "./types"
 import * as patterns from "./util/patterns"
-import { Utils } from "./util/utils"
 import { DependencyConfig, Update } from "./dependencyConfig/DependencyConfig"
 import { BackupSet, Backups } from "./backup/Backups"
 import { smtpConfig } from "./config/configConstants"
@@ -53,6 +58,19 @@ import {
 } from "./interfaces/setupInterfaces"
 import { successFailure } from "./trigger/successFailure"
 import { SetupExports } from "./inits/setupExports"
+import { HealthReceipt } from "./health/HealthReceipt"
+import { MultiHost, Scheme, SingleHost, StaticHost } from "./interfaces/Host"
+import { ServiceInterfaceBuilder } from "./interfaces/ServiceInterfaceBuilder"
+import { GetSystemSmtp } from "./util/GetSystemSmtp"
+import nullIfEmpty from "./util/nullIfEmpty"
+import {
+  GetServiceInterface,
+  getServiceInterface,
+} from "./util/getServiceInterface"
+import { getServiceInterfaces } from "./util/getServiceInterfaces"
+import { getStore } from "./store/getStore"
+import { CommandOptions, MountOptions, Overlay } from "./util/Overlay"
+import { splitCommand } from "./util/splitCommand"

 // prettier-ignore
 type AnyNeverCond<T extends any[], Then, Else> = 
@@ -61,6 +79,17 @@ type AnyNeverCond<T extends any[], Then, Else> =
    T extends [any, ...infer U] ? AnyNeverCond<U,Then, Else> :
    never

+export type ServiceInterfaceType = "ui" | "p2p" | "api"
+export type MainEffects = Effects & { _type: "main" }
+export type Signals = NodeJS.Signals
+export const SIGTERM: Signals = "SIGTERM"
+export const SIGKILL: Signals = "SIGTERM"
+export const NO_TIMEOUT = -1
+
+function removeConstType<E>() {
+  return <T>(t: T) => t as T & (E extends MainEffects ? {} : { const: never })
+}
+
 export class StartSdk<Manifest extends SDKManifest, Store> {
  private constructor(readonly manifest: Manifest) {}
  static of() {
@@ -75,7 +104,78 @@ export class StartSdk<Manifest extends SDKManifest, Store> {

  build(isReady: AnyNeverCond<[Manifest, Store], "Build not ready", true>) {
    return {
+      serviceInterface: {
+        getOwn: <E extends Effects>(effects: E, id: ServiceInterfaceId) =>
+          removeConstType<E>()(
+            getServiceInterface(effects, {
+              id,
+              packageId: null,
+            }),
+          ),
+        get: <E extends Effects>(
+          effects: E,
+          opts: { id: ServiceInterfaceId; packageId: PackageId },
+        ) => removeConstType<E>()(getServiceInterface(effects, opts)),
+        getAllOwn: <E extends Effects>(effects: E) =>
+          removeConstType<E>()(
+            getServiceInterfaces(effects, {
+              packageId: null,
+            }),
+          ),
+        getAll: <E extends Effects>(
+          effects: E,
+          opts: { packageId: PackageId },
+        ) => removeConstType<E>()(getServiceInterfaces(effects, opts)),
+      },
+
+      store: {
+        get: <E extends Effects, Path extends string = never>(
+          effects: E,
+          packageId: string,
+          path: EnsureStorePath<Store, Path>,
+        ) =>
+          removeConstType<E>()(
+            getStore<Store, Path>(effects, path as any, {
+              packageId,
+            }),
+          ),
+        getOwn: <E extends Effects, Path extends string>(
+          effects: E,
+          path: EnsureStorePath<Store, Path>,
+        ) => removeConstType<E>()(getStore<Store, Path>(effects, path as any)),
+        setOwn: <E extends Effects, Path extends string | never>(
+          effects: E,
+          path: EnsureStorePath<Store, Path>,
+          value: ExtractStore<Store, Path>,
+        ) => effects.store.set<Store, Path>({ value, path: path as any }),
+      },
+
+      host: {
+        static: (effects: Effects, id: string) =>
+          new StaticHost({ id, effects }),
+        single: (effects: Effects, id: string) =>
+          new SingleHost({ id, effects }),
+        multi: (effects: Effects, id: string) => new MultiHost({ id, effects }),
+      },
+      nullIfEmpty,
+
      configConstants: { smtpConfig },
+      createInterface: (
+        effects: Effects,
+        options: {
+          name: string
+          id: string
+          description: string
+          hasPrimary: boolean
+          disabled: boolean
+          type: ServiceInterfaceType
+          username: null | string
+          path: string
+          search: Record<string, string>
+          schemeOverride: { ssl: Scheme; noSsl: Scheme } | null
+          masked: boolean
+        },
+      ) => new ServiceInterfaceBuilder({ ...options, effects }),
      createAction: <
        ConfigType extends
          | Record<string, any>
@@ -88,13 +188,34 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
        },
        fn: (options: {
          effects: Effects
-          utils: Utils<Manifest, Store>
          input: Type
        }) => Promise<ActionResult>,
      ) => {
        const { input, ...rest } = metaData
        return createAction<Manifest, Store, ConfigType, Type>(rest, fn, input)
      },
+      getSystemSmtp: <E extends Effects>(effects: E) =>
+        removeConstType<E>()(new GetSystemSmtp(effects)),
+      runCommand: async <A extends string>(
+        effects: Effects,
+        imageId: Manifest["images"][number],
+        command: ValidIfNoStupidEscape<A> | [string, ...string[]],
+        options: CommandOptions & {
+          mounts?: { path: string; options: MountOptions }[]
+        },
+      ): Promise<{ stdout: string | Buffer; stderr: string | Buffer }> => {
+        const commands = splitCommand(command)
+        const overlay = await Overlay.of(effects, imageId)
+        try {
+          for (let mount of options.mounts || []) {
+            await overlay.mount(mount.options, mount.path)
+          }
+          return await overlay.exec(commands)
+        } finally {
+          await overlay.destroy()
+        }
+      },
+
      createDynamicAction: <
        ConfigType extends
          | Record<string, any>
@@ -104,11 +225,9 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
      >(
        metaData: (options: {
          effects: Effects
-          utils: Utils<Manifest, Store>
        }) => MaybePromise<Omit<ActionMetadata, "input">>,
        fn: (options: {
          effects: Effects
-          utils: Utils<Manifest, Store>
          input: Type
        }) => Promise<ActionResult>,
        input: Config<Type, Store> | Config<Type, never>,
@@ -193,9 +312,8 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
      ) => setupInterfaces(config, fn),
      setupMain: (
        fn: (o: {
-          effects: Effects
+          effects: MainEffects
          started(onTerm: () => PromiseLike<void>): PromiseLike<void>
-          utils: Utils<Manifest, Store, {}>
        }) => Promise<Daemons<Manifest, any>>,
      ) => setupMain<Manifest, Store>(fn),
      setupMigrations: <
@@ -232,7 +350,15 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
          spec: Spec,
        ) => Config.of<Spec, Store>(spec),
      },
-      Daemons: { of: Daemons.of },
+      Daemons: {
+        of(config: {
+          effects: Effects
+          started: (onTerm: () => PromiseLike<void>) => PromiseLike<void>
+          healthReceipts: HealthReceipt[]
+        }) {
+          return Daemons.of<Manifest>(config)
+        },
+      },
      DependencyConfig: {
        of<
          LocalConfig extends Record<string, any>,
@@ -248,7 +374,6 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
          dependencyConfig: (options: {
            effects: Effects
            localConfig: LocalConfig
-            utils: Utils<Manifest, Store>
          }) => Promise<void | DeepPartial<RemoteConfig>>
          update?: Update<void | DeepPartial<RemoteConfig>, RemoteConfig>
        }) {
@@ -332,14 +457,8 @@ export class StartSdk<Manifest extends SDKManifest, Store> {
      Migration: {
        of: <Version extends ManifestVersion>(options: {
          version: Version
-          up: (opts: {
-            effects: Effects
-            utils: Utils<Manifest, Store>
-          }) => Promise<void>
-          down: (opts: {
-            effects: Effects
-            utils: Utils<Manifest, Store>
-          }) => Promise<void>
+          up: (opts: { effects: Effects }) => Promise<void>
+          down: (opts: { effects: Effects }) => Promise<void>
        }) => Migration.of<Manifest, Store, Version>(options),
      },
      Value: {
--- a/sdk/lib/actions/createAction.ts
+++ b/sdk/lib/actions/createAction.ts
@@ -1,15 +1,10 @@
 import { Config, ExtractConfigType } from "../config/builder/config"
 import { SDKManifest } from "../manifest/ManifestTypes"
 import { ActionMetadata, ActionResult, Effects, ExportedAction } from "../types"
-import { createUtils } from "../util"
-import { Utils } from "../util/utils"

 export type MaybeFn<Manifest extends SDKManifest, Store, Value> =
  | Value
-  | ((options: {
-      effects: Effects
-      utils: Utils<Manifest, Store>
-    }) => Promise<Value> | Value)
+  | ((options: { effects: Effects }) => Promise<Value> | Value)
 export class CreatedAction<
  Manifest extends SDKManifest,
  Store,
@@ -27,7 +22,6 @@ export class CreatedAction<
    >,
    readonly fn: (options: {
      effects: Effects
-      utils: Utils<Manifest, Store>
      input: Type
    }) => Promise<ActionResult>,
    readonly input: Config<Type, Store>,
@@ -44,11 +38,7 @@ export class CreatedAction<
    Type extends Record<string, any> = ExtractConfigType<ConfigType>,
  >(
    metaData: MaybeFn<Manifest, Store, Omit<ActionMetadata, "input">>,
-    fn: (options: {
-      effects: Effects
-      utils: Utils<Manifest, Store>
-      input: Type
-    }) => Promise<ActionResult>,
+    fn: (options: { effects: Effects; input: Type }) => Promise<ActionResult>,
    inputConfig: Config<Type, Store> | Config<Type, never>,
  ) {
    return new CreatedAction<Manifest, Store, ConfigType, Type>(
@@ -61,7 +51,6 @@ export class CreatedAction<
  exportedAction: ExportedAction = ({ effects, input }) => {
    return this.fn({
      effects,
-      utils: createUtils(effects),
      input: this.validator.unsafeCast(input),
    })
  }
@@ -69,21 +58,17 @@ export class CreatedAction<
  run = async ({ effects, input }: { effects: Effects; input?: Type }) => {
    return this.fn({
      effects,
-      utils: createUtils(effects),
      input: this.validator.unsafeCast(input),
    })
  }

-  async metaData(options: { effects: Effects; utils: Utils<Manifest, Store> }) {
+  async metaData(options: { effects: Effects }) {
    if (this.myMetaData instanceof Function)
      return await this.myMetaData(options)
    return this.myMetaData
  }

-  async ActionMetadata(options: {
-    effects: Effects
-    utils: Utils<Manifest, Store>
-  }): Promise<ActionMetadata> {
+  async ActionMetadata(options: { effects: Effects }): Promise<ActionMetadata> {
    return {
      ...(await this.metaData(options)),
      input: await this.input.build(options),
@@ -93,7 +78,6 @@ export class CreatedAction<
  async getConfig({ effects }: { effects: Effects }) {
    return this.input.build({
      effects,
-      utils: createUtils(effects) as any,
    })
  }
 }
--- a/sdk/lib/actions/setupActions.ts
+++ b/sdk/lib/actions/setupActions.ts
@@ -1,17 +1,12 @@
 import { SDKManifest } from "../manifest/ManifestTypes"
 import { Effects, ExpectedExports } from "../types"
-import { createUtils } from "../util"
 import { once } from "../util/once"
-import { Utils } from "../util/utils"
 import { CreatedAction } from "./createAction"

 export function setupActions<Manifest extends SDKManifest, Store>(
  ...createdActions: CreatedAction<Manifest, Store, any>[]
 ) {
-  const myActions = async (options: {
-    effects: Effects
-    utils: Utils<Manifest, Store>
-  }) => {
+  const myActions = async (options: { effects: Effects }) => {
    const actions: Record<string, CreatedAction<Manifest, Store, any>> = {}
    for (const action of createdActions) {
      const actionMetadata = await action.metaData(options)
@@ -24,17 +19,11 @@ export function setupActions<Manifest extends SDKManifest, Store>(
    actionsMetadata: ExpectedExports.actionsMetadata
  } = {
    actions(options: { effects: Effects }) {
-      const utils = createUtils<Manifest, Store>(options.effects)
-
-      return myActions({
-        ...options,
-        utils,
-      })
+      return myActions(options)
    },
    async actionsMetadata({ effects }: { effects: Effects }) {
-      const utils = createUtils<Manifest, Store>(effects)
      return Promise.all(
-        createdActions.map((x) => x.ActionMetadata({ effects, utils })),
+        createdActions.map((x) => x.ActionMetadata({ effects })),
      )
    },
  }
--- a/sdk/lib/backup/Backups.ts
+++ b/sdk/lib/backup/Backups.ts
@@ -42,7 +42,7 @@ export class Backups<M extends SDKManifest> {

  private constructor(
    private options = DEFAULT_OPTIONS,
-    private backupSet = [] as BackupSet<M["volumes"][0]>[],
+    private backupSet = [] as BackupSet<M["volumes"][number]>[],
  ) {}
  static volumes<M extends SDKManifest = never>(
    ...volumeNames: Array<M["volumes"][0]>
--- a/sdk/lib/backup/setupBackups.ts
+++ b/sdk/lib/backup/setupBackups.ts
@@ -4,7 +4,7 @@ import { ExpectedExports } from "../types"
 import { _ } from "../util"

 export type SetupBackupsParams<M extends SDKManifest> = Array<
-  M["volumes"][0] | Backups<M>
+  M["volumes"][number] | Backups<M>
 >

 export function setupBackups<M extends SDKManifest>(
--- a/sdk/lib/config/builder/config.ts
+++ b/sdk/lib/config/builder/config.ts
@@ -1,5 +1,4 @@
 import { ValueSpec } from "../configTypes"
-import { Utils } from "../../util/utils"
 import { Value } from "./value"
 import { _ } from "../../util"
 import { Effects } from "../../types"
@@ -7,7 +6,6 @@ import { Parser, object } from "ts-matches"

 export type LazyBuildOptions<Store> = {
  effects: Effects
-  utils: Utils<any, Store>
 }
 export type LazyBuild<Store, ExpectedOut> = (
  options: LazyBuildOptions<Store>,
--- a/sdk/lib/config/configConstants.ts
+++ b/sdk/lib/config/configConstants.ts
@@ -1,4 +1,5 @@
 import { SmtpValue } from "../types"
+import { GetSystemSmtp } from "../util/GetSystemSmtp"
 import { email } from "../util/patterns"
 import { Config, ConfigSpecOf } from "./builder/config"
 import { Value } from "./builder/value"
@@ -47,8 +48,8 @@ export const customSmtp = Config.of<ConfigSpecOf<SmtpValue>, never>({
 * For service config. Gives users 3 options for SMTP: (1) disabled, (2) use system SMTP settings, (3) use custom SMTP settings
 */
 export const smtpConfig = Value.filteredUnion(
-  async ({ effects, utils }) => {
-    const smtp = await utils.getSystemSmtp().once()
+  async ({ effects }) => {
+    const smtp = await new GetSystemSmtp(effects).once()
    return smtp ? [] : ["system"]
  },
  {
--- a/sdk/lib/config/configDependencies.ts
+++ b/sdk/lib/config/configDependencies.ts
@@ -3,7 +3,7 @@ import { Dependency } from "../types"

 export type ConfigDependencies<T extends SDKManifest> = {
  exists(id: keyof T["dependencies"]): Dependency
-  running(id: keyof T["dependencies"]): Dependency
+  running(id: keyof T["dependencies"], healthChecks: string[]): Dependency
 }

 export const configDependenciesSet = <
@@ -16,10 +16,11 @@ export const configDependenciesSet = <
    } as Dependency
  },

-  running(id: keyof T["dependencies"]) {
+  running(id: keyof T["dependencies"], healthChecks: string[]) {
    return {
      id,
      kind: "running",
+      healthChecks,
    } as Dependency
  },
 })
--- a/sdk/lib/config/setupConfig.ts
+++ b/sdk/lib/config/setupConfig.ts
@@ -2,7 +2,6 @@ import { Effects, ExpectedExports } from "../types"
 import { SDKManifest } from "../manifest/ManifestTypes"
 import * as D from "./configDependencies"
 import { Config, ExtractConfigType } from "./builder/config"
-import { Utils, createUtils } from "../util/utils"
 import nullIfEmpty from "../util/nullIfEmpty"
 import { InterfaceReceipt } from "../interfaces/interfaceReceipt"
 import { InterfacesReceipt as InterfacesReceipt } from "../interfaces/setupInterfaces"
@@ -22,7 +21,6 @@ export type Save<
 > = (options: {
  effects: Effects
  input: ExtractConfigType<A> & Record<string, any>
-  utils: Utils<Manifest, Store>
  dependencies: D.ConfigDependencies<Manifest>
 }) => Promise<{
  dependenciesReceipt: DependenciesReceipt
@@ -38,7 +36,6 @@ export type Read<
    | Config<Record<string, any>, never>,
 > = (options: {
  effects: Effects
-  utils: Utils<Manifest, Store>
 }) => Promise<void | (ExtractConfigType<A> & Record<string, any>)>
 /**
 * We want to setup a config export with a get and set, this
@@ -72,7 +69,6 @@ export function setupConfig<
      const { restart } = await write({
        input: JSON.parse(JSON.stringify(input)),
        effects,
-        utils: createUtils(effects),
        dependencies: D.configDependenciesSet<Manifest>(),
      })
      if (restart) {
@@ -80,14 +76,10 @@ export function setupConfig<
      }
    }) as ExpectedExports.setConfig,
    getConfig: (async ({ effects }) => {
-      const myUtils = createUtils<Manifest, Store>(effects)
-      const configValue = nullIfEmpty(
-        (await read({ effects, utils: myUtils })) || null,
-      )
+      const configValue = nullIfEmpty((await read({ effects })) || null)
      return {
        spec: await spec.build({
          effects,
-          utils: myUtils as any,
        }),
        config: configValue,
      }
--- a/sdk/lib/dependencyConfig/DependencyConfig.ts
+++ b/sdk/lib/dependencyConfig/DependencyConfig.ts
@@ -3,7 +3,6 @@ import {
  DeepPartial,
  Effects,
 } from "../types"
-import { Utils, createUtils } from "../util/utils"
 import { deepEqual } from "../util/deepEqual"
 import { deepMerge } from "../util/deepMerge"
 import { SDKManifest } from "../manifest/ManifestTypes"
@@ -29,7 +28,6 @@ export class DependencyConfig<
    readonly dependencyConfig: (options: {
      effects: Effects
      localConfig: Input
-      utils: Utils<Manifest, Store>
    }) => Promise<void | DeepPartial<RemoteConfig>>,
    readonly update: Update<
      void | DeepPartial<RemoteConfig>,
@@ -41,7 +39,6 @@ export class DependencyConfig<
    return this.dependencyConfig({
      localConfig: options.localConfig as Input,
      effects: options.effects,
-      utils: createUtils<Manifest, Store>(options.effects),
    })
  }
 }
--- a/sdk/lib/health/HealthCheck.ts
+++ b/sdk/lib/health/HealthCheck.ts
@@ -6,52 +6,59 @@ import { Trigger } from "../trigger"
 import { TriggerInput } from "../trigger/TriggerInput"
 import { defaultTrigger } from "../trigger/defaultTrigger"
 import { once } from "../util/once"
+import { Overlay } from "../util/Overlay"

 export function healthCheck(o: {
  effects: Effects
  name: string
+  imageId: string
  trigger?: Trigger
-  fn(): Promise<CheckResult> | CheckResult
+  fn(overlay: Overlay): Promise<CheckResult> | CheckResult
  onFirstSuccess?: () => unknown | Promise<unknown>
 }) {
  new Promise(async () => {
-    let currentValue: TriggerInput = {
-      hadSuccess: false,
-    }
-    const getCurrentValue = () => currentValue
-    const trigger = (o.trigger ?? defaultTrigger)(getCurrentValue)
-    const triggerFirstSuccess = once(() =>
-      Promise.resolve(
-        "onFirstSuccess" in o && o.onFirstSuccess
-          ? o.onFirstSuccess()
-          : undefined,
-      ),
-    )
-    for (
-      let res = await trigger.next();
-      !res.done;
-      res = await trigger.next()
-    ) {
-      try {
-        const { status, message } = await o.fn()
-        await o.effects.setHealth({
-          name: o.name,
-          status,
-          message,
-        })
-        currentValue.hadSuccess = true
-        currentValue.lastResult = "passing"
-        await triggerFirstSuccess().catch((err) => {
-          console.error(err)
-        })
-      } catch (e) {
-        await o.effects.setHealth({
-          name: o.name,
-          status: "failure",
-          message: asMessage(e),
-        })
-        currentValue.lastResult = "failure"
+    const overlay = await Overlay.of(o.effects, o.imageId)
+    try {
+      let currentValue: TriggerInput = {
+        hadSuccess: false,
      }
+      const getCurrentValue = () => currentValue
+      const trigger = (o.trigger ?? defaultTrigger)(getCurrentValue)
+      const triggerFirstSuccess = once(() =>
+        Promise.resolve(
+          "onFirstSuccess" in o && o.onFirstSuccess
+            ? o.onFirstSuccess()
+            : undefined,
+        ),
+      )
+      for (
+        let res = await trigger.next();
+        !res.done;
+        res = await trigger.next()
+      ) {
+        try {
+          const { status, message } = await o.fn(overlay)
+          await o.effects.setHealth({
+            name: o.name,
+            status,
+            message,
+          })
+          currentValue.hadSuccess = true
+          currentValue.lastResult = "passing"
+          await triggerFirstSuccess().catch((err) => {
+            console.error(err)
+          })
+        } catch (e) {
+          await o.effects.setHealth({
+            name: o.name,
+            status: "failure",
+            message: asMessage(e),
+          })
+          currentValue.lastResult = "failure"
+        }
+      }
+    } finally {
+      await overlay.destroy()
    }
  })
  return {} as HealthReceipt
--- a/sdk/lib/health/checkFns/checkPortListening.ts
+++ b/sdk/lib/health/checkFns/checkPortListening.ts
@@ -1,7 +1,12 @@
 import { Effects } from "../../types"
-import { createUtils } from "../../util"
 import { stringFromStdErrOut } from "../../util/stringFromStdErrOut"
 import { CheckResult } from "./CheckResult"
+
+import { promisify } from "node:util"
+import * as CP from "node:child_process"
+
+const cpExec = promisify(CP.exec)
+const cpExecFile = promisify(CP.execFile)
 export function containsAddress(x: string, port: number) {
  const readPorts = x
    .split("\n")
@@ -28,20 +33,15 @@ export async function checkPortListening(
    timeout?: number
  },
 ): Promise<CheckResult> {
-  const utils = createUtils(effects)
  return Promise.race<CheckResult>([
    Promise.resolve().then(async () => {
      const hasAddress =
        containsAddress(
-          await utils.childProcess
-            .exec(`cat /proc/net/tcp`, {})
-            .then(stringFromStdErrOut),
+          await cpExec(`cat /proc/net/tcp`, {}).then(stringFromStdErrOut),
          port,
        ) ||
        containsAddress(
-          await utils.childProcess
-            .exec("cat /proc/net/udp", {})
-            .then(stringFromStdErrOut),
+          await cpExec("cat /proc/net/udp", {}).then(stringFromStdErrOut),
          port,
        )
      if (hasAddress) {
--- a/sdk/lib/health/checkFns/runHealthScript.ts
+++ b/sdk/lib/health/checkFns/runHealthScript.ts
@@ -1,5 +1,5 @@
-import { CommandType, Effects } from "../../types"
-import { createUtils } from "../../util"
+import { Effects } from "../../types"
+import { Overlay } from "../../util/Overlay"
 import { stringFromStdErrOut } from "../../util/stringFromStdErrOut"
 import { CheckResult } from "./CheckResult"
 import { timeoutPromise } from "./index"
@@ -13,7 +13,8 @@ import { timeoutPromise } from "./index"
 */
 export const runHealthScript = async (
  effects: Effects,
-  runCommand: string,
+  runCommand: string[],
+  overlay: Overlay,
  {
    timeout = 30000,
    errorMessage = `Error while running command: ${runCommand}`,
@@ -21,9 +22,8 @@ export const runHealthScript = async (
      `Have ran script ${runCommand} and the result: ${res}`,
  } = {},
 ): Promise<CheckResult> => {
-  const utils = createUtils(effects)
  const res = await Promise.race([
-    utils.childProcess.exec(runCommand, { timeout }).then(stringFromStdErrOut),
+    overlay.exec(runCommand),
    timeoutPromise(timeout),
  ]).catch((e) => {
    console.warn(errorMessage)
@@ -33,6 +33,6 @@ export const runHealthScript = async (
  })
  return {
    status: "passing",
-    message: message(res),
+    message: message(res.stdout.toString()),
  } as CheckResult
 }
--- a/sdk/lib/index.ts
+++ b/sdk/lib/index.ts
@@ -1,9 +1,9 @@
 export { Daemons } from "./mainFn/Daemons"
 export { EmVer } from "./emverLite/mod"
 export { Overlay } from "./util/Overlay"
-export { Utils } from "./util/utils"
 export { StartSdk } from "./StartSdk"
 export { setupManifest } from "./manifest/setupManifest"
+export { FileHelper } from "./util/fileHelper"
 export * as actions from "./actions"
 export * as backup from "./backup"
 export * as config from "./config"
--- a/sdk/lib/inits/migrations/Migration.ts
+++ b/sdk/lib/inits/migrations/Migration.ts
@@ -1,6 +1,5 @@
 import { ManifestVersion, SDKManifest } from "../../manifest/ManifestTypes"
 import { Effects } from "../../types"
-import { Utils } from "../../util/utils"

 export class Migration<
  Manifest extends SDKManifest,
@@ -10,14 +9,8 @@ export class Migration<
  constructor(
    readonly options: {
      version: Version
-      up: (opts: {
-        effects: Effects
-        utils: Utils<Manifest, Store>
-      }) => Promise<void>
-      down: (opts: {
-        effects: Effects
-        utils: Utils<Manifest, Store>
-      }) => Promise<void>
+      up: (opts: { effects: Effects }) => Promise<void>
+      down: (opts: { effects: Effects }) => Promise<void>
    },
  ) {}
  static of<
@@ -26,23 +19,17 @@ export class Migration<
    Version extends ManifestVersion,
  >(options: {
    version: Version
-    up: (opts: {
-      effects: Effects
-      utils: Utils<Manifest, Store>
-    }) => Promise<void>
-    down: (opts: {
-      effects: Effects
-      utils: Utils<Manifest, Store>
-    }) => Promise<void>
+    up: (opts: { effects: Effects }) => Promise<void>
+    down: (opts: { effects: Effects }) => Promise<void>
  }) {
    return new Migration<Manifest, Store, Version>(options)
  }

-  async up(opts: { effects: Effects; utils: Utils<Manifest, Store> }) {
+  async up(opts: { effects: Effects }) {
    this.up(opts)
  }

-  async down(opts: { effects: Effects; utils: Utils<Manifest, Store> }) {
+  async down(opts: { effects: Effects }) {
    this.down(opts)
  }
 }
--- a/sdk/lib/inits/migrations/setupMigrations.ts
+++ b/sdk/lib/inits/migrations/setupMigrations.ts
@@ -1,7 +1,6 @@
 import { EmVer } from "../../emverLite/mod"
 import { SDKManifest } from "../../manifest/ManifestTypes"
 import { ExpectedExports } from "../../types"
-import { createUtils } from "../../util"
 import { once } from "../../util/once"
 import { Migration } from "./Migration"

@@ -32,13 +31,12 @@ export class Migrations<Manifest extends SDKManifest, Store> {
    effects,
    previousVersion,
  }: Parameters<ExpectedExports.init>[0]) {
-    const utils = createUtils<Manifest, Store>(effects)
    if (!!previousVersion) {
      const previousVersionEmVer = EmVer.parse(previousVersion)
      for (const [_, migration] of this.sortedMigrations()
        .filter((x) => x[0].greaterThan(previousVersionEmVer))
        .filter((x) => x[0].lessThanOrEqual(this.currentVersion()))) {
-        await migration.up({ effects, utils })
+        await migration.up({ effects })
      }
    }
  }
@@ -46,14 +44,13 @@ export class Migrations<Manifest extends SDKManifest, Store> {
    effects,
    nextVersion,
  }: Parameters<ExpectedExports.uninit>[0]) {
-    const utils = createUtils<Manifest, Store>(effects)
    if (!!nextVersion) {
      const nextVersionEmVer = EmVer.parse(nextVersion)
      const reversed = [...this.sortedMigrations()].reverse()
      for (const [_, migration] of reversed
        .filter((x) => x[0].greaterThan(nextVersionEmVer))
        .filter((x) => x[0].lessThanOrEqual(this.currentVersion()))) {
-        await migration.down({ effects, utils })
+        await migration.down({ effects })
      }
    }
  }
--- a/sdk/lib/inits/setupExports.ts
+++ b/sdk/lib/inits/setupExports.ts
@@ -1,16 +1,12 @@
 import { Effects, ExposeServicePaths, ExposeUiPaths } from "../types"
-import { Utils } from "../util/utils"

-export type SetupExports<Store> = (opts: {
-  effects: Effects
-  utils: Utils<any, Store>
-}) =>
+export type SetupExports<Store> = (opts: { effects: Effects }) =>
  | {
-      ui: ExposeUiPaths<Store>
+      ui: { [k: string]: ExposeUiPaths<Store> }
      services: ExposeServicePaths<Store>
    }
  | Promise<{
-      ui: ExposeUiPaths<Store>
+      ui: { [k: string]: ExposeUiPaths<Store> }
      services: ExposeServicePaths<Store>
    }>

--- a/sdk/lib/inits/setupInit.ts
+++ b/sdk/lib/inits/setupInit.ts
@@ -1,7 +1,6 @@
 import { SetInterfaces } from "../interfaces/setupInterfaces"
 import { SDKManifest } from "../manifest/ManifestTypes"
-import { ExpectedExports } from "../types"
-import { createUtils } from "../util"
+import { ExpectedExports, ExposeUiPaths, ExposeUiPathsAll } from "../types"
 import { Migrations } from "./migrations/setupMigrations"
 import { SetupExports } from "./setupExports"
 import { Install } from "./setupInstall"
@@ -19,20 +18,20 @@ export function setupInit<Manifest extends SDKManifest, Store>(
 } {
  return {
    init: async (opts) => {
-      const utils = createUtils<Manifest, Store>(opts.effects)
      await migrations.init(opts)
      await install.init(opts)
      await setInterfaces({
        ...opts,
        input: null,
-        utils,
-      })
-      const { services, ui } = await setupExports({
-        ...opts,
-        utils,
      })
+      const { services, ui } = await setupExports(opts)
      await opts.effects.exposeForDependents(services)
-      await opts.effects.exposeUi({ paths: ui })
+      await opts.effects.exposeUi(
+        forExpose({
+          type: "object",
+          value: ui,
+        }),
+      )
    },
    uninit: async (opts) => {
      await migrations.uninit(opts)
@@ -40,3 +39,21 @@ export function setupInit<Manifest extends SDKManifest, Store>(
    },
  }
 }
+
+function forExpose<Store>(ui: ExposeUiPaths<Store>): ExposeUiPathsAll {
+  if (ui.type === ("object" as const)) {
+    return {
+      type: "object" as const,
+      value: Object.fromEntries(
+        Object.entries(ui.value).map(([key, value]) => [key, forExpose(value)]),
+      ),
+    }
+  }
+  return {
+    description: null,
+
+    copyable: null,
+    qr: null,
+    ...ui,
+  }
+}
--- a/sdk/lib/inits/setupInstall.ts
+++ b/sdk/lib/inits/setupInstall.ts
@@ -1,10 +1,8 @@
 import { SDKManifest } from "../manifest/ManifestTypes"
 import { Effects, ExpectedExports } from "../types"
-import { Utils, createUtils } from "../util/utils"

 export type InstallFn<Manifest extends SDKManifest, Store> = (opts: {
  effects: Effects
-  utils: Utils<Manifest, Store>
 }) => Promise<void>
 export class Install<Manifest extends SDKManifest, Store> {
  private constructor(readonly fn: InstallFn<Manifest, Store>) {}
@@ -21,7 +19,6 @@ export class Install<Manifest extends SDKManifest, Store> {
    if (!previousVersion)
      await this.fn({
        effects,
-        utils: createUtils(effects),
      })
  }
 }
--- a/sdk/lib/inits/setupUninstall.ts
+++ b/sdk/lib/inits/setupUninstall.ts
@@ -1,10 +1,8 @@
 import { SDKManifest } from "../manifest/ManifestTypes"
 import { Effects, ExpectedExports } from "../types"
-import { Utils, createUtils } from "../util/utils"

 export type UninstallFn<Manifest extends SDKManifest, Store> = (opts: {
  effects: Effects
-  utils: Utils<Manifest, Store>
 }) => Promise<void>
 export class Uninstall<Manifest extends SDKManifest, Store> {
  private constructor(readonly fn: UninstallFn<Manifest, Store>) {}
@@ -21,7 +19,6 @@ export class Uninstall<Manifest extends SDKManifest, Store> {
    if (!nextVersion)
      await this.fn({
        effects,
-        utils: createUtils(effects),
      })
  }
 }
--- a/sdk/lib/interfaces/Host.ts
+++ b/sdk/lib/interfaces/Host.ts
@@ -59,12 +59,13 @@ type AddSslOptions = {
  preferredExternalPort: number
  addXForwardedHeaders: boolean | null /** default: false */
 }
-type Security = { secure: false; ssl: false } | { secure: true; ssl: boolean }
+type Security = { ssl: boolean }
 export type BindOptions = {
  scheme: Scheme
  preferredExternalPort: number
  addSsl: AddSslOptions | null
-} & Security
+  secure: Security | null
+}
 type KnownProtocols = typeof knownProtocols
 type ProtocolsWithSslVariants = {
  [K in keyof KnownProtocols]: KnownProtocols[K] extends {
@@ -79,16 +80,17 @@ type NotProtocolsWithSslVariants = Exclude<
 >

 type BindOptionsByKnownProtocol =
-  | ({
+  | {
      protocol: ProtocolsWithSslVariants
      preferredExternalPort?: number
-      scheme: Scheme | null
-    } & ({ noAddSsl: true } | { addSsl?: Partial<AddSslOptions> }))
+      scheme?: Scheme
+      addSsl?: Partial<AddSslOptions>
+    }
  | {
      protocol: NotProtocolsWithSslVariants
      preferredExternalPort?: number
-      scheme: Scheme | null
-      addSsl: AddSslOptions | null
+      scheme?: Scheme
+      addSsl?: AddSslOptions
    }
 type BindOptionsByProtocol = BindOptionsByKnownProtocol | BindOptions

@@ -120,17 +122,12 @@ export class Host {

  private async bindPortForUnknown(
    internalPort: number,
-    options:
-      | ({
-          scheme: Scheme
-          preferredExternalPort: number
-          addSsl: AddSslOptions | null
-        } & { secure: false; ssl: false })
-      | ({
-          scheme: Scheme
-          preferredExternalPort: number
-          addSsl: AddSslOptions | null
-        } & { secure: true; ssl: boolean }),
+    options: {
+      scheme: Scheme
+      preferredExternalPort: number
+      addSsl: AddSslOptions | null
+      secure: { ssl: boolean } | null
+    },
  ) {
    await this.options.effects.bind({
      kind: this.options.kind,
@@ -154,18 +151,13 @@ export class Host {
      knownProtocols[options.protocol].defaultPort
    const addSsl = this.getAddSsl(options, protoInfo)

-    const security: Security = !protoInfo.secure
-      ? {
-          secure: protoInfo.secure,
-          ssl: protoInfo.ssl,
-        }
-      : { secure: false, ssl: false }
+    const secure: Security | null = !protoInfo.secure ? null : { ssl: false }

    const newOptions = {
      scheme,
      preferredExternalPort,
      addSsl,
-      ...security,
+      secure,
    }

    await this.options.effects.bind({
--- a/sdk/lib/interfaces/ServiceInterfaceBuilder.ts
+++ b/sdk/lib/interfaces/ServiceInterfaceBuilder.ts
@@ -1,5 +1,5 @@
+import { ServiceInterfaceType } from "../StartSdk"
 import { Effects } from "../types"
-import { ServiceInterfaceType } from "../util/utils"
 import { Scheme } from "./Host"

 /**
--- a/sdk/lib/interfaces/setupInterfaces.ts
+++ b/sdk/lib/interfaces/setupInterfaces.ts
@@ -1,7 +1,6 @@
 import { Config } from "../config/builder/config"
 import { SDKManifest } from "../manifest/ManifestTypes"
 import { AddressInfo, Effects } from "../types"
-import { Utils } from "../util/utils"
 import { AddressReceipt } from "./AddressReceipt"

 export type InterfacesReceipt = Array<AddressInfo[] & AddressReceipt>
@@ -10,11 +9,7 @@ export type SetInterfaces<
  Store,
  ConfigInput extends Record<string, any>,
  Output extends InterfacesReceipt,
-> = (opts: {
-  effects: Effects
-  input: null | ConfigInput
-  utils: Utils<Manifest, Store>
-}) => Promise<Output>
+> = (opts: { effects: Effects; input: null | ConfigInput }) => Promise<Output>
 export type SetupInterfaces = <
  Manifest extends SDKManifest,
  Store,
--- a/sdk/lib/mainFn/Daemons.ts
+++ b/sdk/lib/mainFn/Daemons.ts
@@ -1,3 +1,4 @@
+import { NO_TIMEOUT, SIGKILL, SIGTERM, Signals } from "../StartSdk"
 import { HealthReceipt } from "../health/HealthReceipt"
 import { CheckResult } from "../health/checkFns"
 import { SDKManifest } from "../manifest/ManifestTypes"
@@ -5,9 +6,22 @@ import { Trigger } from "../trigger"
 import { TriggerInput } from "../trigger/TriggerInput"
 import { defaultTrigger } from "../trigger/defaultTrigger"
 import { DaemonReturned, Effects, ValidIfNoStupidEscape } from "../types"
-import { createUtils } from "../util"
-import { Signals } from "../util/utils"
 import { Mounts } from "./Mounts"
+import { CommandOptions, MountOptions, Overlay } from "../util/Overlay"
+import { splitCommand } from "../util/splitCommand"
+
+import { promisify } from "node:util"
+import * as CP from "node:child_process"
+
+const cpExec = promisify(CP.exec)
+const cpExecFile = promisify(CP.execFile)
+async function psTree(pid: number, overlay: Overlay): Promise<number[]> {
+  const { stdout } = await cpExec(`pstree -p ${pid}`)
+  const regex: RegExp = /\((\d+)\)/g
+  return [...stdout.toString().matchAll(regex)].map(([_all, pid]) =>
+    parseInt(pid),
+  )
+}
 type Daemon<
  Manifest extends SDKManifest,
  Ids extends string,
@@ -28,6 +42,89 @@ type Daemon<
 }

 type ErrorDuplicateId<Id extends string> = `The id '${Id}' is already used`
+
+const runDaemon =
+  <Manifest extends SDKManifest>() =>
+  async <A extends string>(
+    effects: Effects,
+    imageId: Manifest["images"][number],
+    command: ValidIfNoStupidEscape<A> | [string, ...string[]],
+    options: CommandOptions & {
+      mounts?: { path: string; options: MountOptions }[]
+      overlay?: Overlay
+    },
+  ): Promise<DaemonReturned> => {
+    const commands = splitCommand(command)
+    const overlay = options.overlay || (await Overlay.of(effects, imageId))
+    for (let mount of options.mounts || []) {
+      await overlay.mount(mount.options, mount.path)
+    }
+    const childProcess = await overlay.spawn(commands, {
+      env: options.env,
+    })
+    const answer = new Promise<null>((resolve, reject) => {
+      childProcess.stdout.on("data", (data: any) => {
+        console.log(data.toString())
+      })
+      childProcess.stderr.on("data", (data: any) => {
+        console.error(data.toString())
+      })
+
+      childProcess.on("exit", (code: any) => {
+        if (code === 0) {
+          return resolve(null)
+        }
+        return reject(new Error(`${commands[0]} exited with code ${code}`))
+      })
+    })
+
+    const pid = childProcess.pid
+    return {
+      async wait() {
+        const pids = pid ? await psTree(pid, overlay) : []
+        try {
+          return await answer
+        } finally {
+          for (const process of pids) {
+            cpExecFile("kill", [`-9`, String(process)]).catch((_) => {})
+          }
+        }
+      },
+      async term({ signal = SIGTERM, timeout = NO_TIMEOUT } = {}) {
+        const pids = pid ? await psTree(pid, overlay) : []
+        try {
+          childProcess.kill(signal)
+
+          if (timeout > NO_TIMEOUT) {
+            const didTimeout = await Promise.race([
+              new Promise((resolve) => setTimeout(resolve, timeout)).then(
+                () => true,
+              ),
+              answer.then(() => false),
+            ])
+            if (didTimeout) {
+              childProcess.kill(SIGKILL)
+            }
+          } else {
+            await answer
+          }
+        } finally {
+          await overlay.destroy()
+        }
+
+        try {
+          for (const process of pids) {
+            await cpExecFile("kill", [`-${signal}`, String(process)])
+          }
+        } finally {
+          for (const process of pids) {
+            cpExecFile("kill", [`-9`, String(process)]).catch((_) => {})
+          }
+        }
+      },
+    }
+  }
+
 /**
 * A class for defining and controlling the service daemons
 ```ts
@@ -106,9 +203,8 @@ export class Daemons<Manifest extends SDKManifest, Ids extends string> {
      )
      daemonsStarted[daemon.id] = requiredPromise.then(async () => {
        const { command, imageId } = daemon
-        const utils = createUtils<Manifest>(effects)

-        const child = utils.runDaemon(imageId, command, {
+        const child = runDaemon<Manifest>()(effects, imageId, command, {
          env: daemon.env,
          mounts: daemon.mounts.build(),
        })
--- a/sdk/lib/mainFn/index.ts
+++ b/sdk/lib/mainFn/index.ts
@@ -1,12 +1,11 @@
-import { Effects, ExpectedExports } from "../types"
-import { createMainUtils } from "../util"
-import { Utils, createUtils } from "../util/utils"
+import { ExpectedExports } from "../types"
 import { Daemons } from "./Daemons"
 import "../interfaces/ServiceInterfaceBuilder"
 import "../interfaces/Origin"

 import "./Daemons"
 import { SDKManifest } from "../manifest/ManifestTypes"
+import { MainEffects } from "../StartSdk"

 /**
 * Used to ensure that the main function is running with the valid proofs.
@@ -20,16 +19,12 @@ import { SDKManifest } from "../manifest/ManifestTypes"
 */
 export const setupMain = <Manifest extends SDKManifest, Store>(
  fn: (o: {
-    effects: Effects
+    effects: MainEffects
    started(onTerm: () => PromiseLike<void>): PromiseLike<void>
-    utils: Utils<Manifest, Store, {}>
  }) => Promise<Daemons<Manifest, any>>,
 ): ExpectedExports.main => {
  return async (options) => {
-    const result = await fn({
-      ...options,
-      utils: createMainUtils<Manifest, Store>(options.effects),
-    })
+    const result = await fn(options)
    return result
  }
 }
--- a/sdk/lib/test/configBuilder.test.ts
+++ b/sdk/lib/test/configBuilder.test.ts
@@ -4,6 +4,8 @@ import { List } from "../config/builder/list"
 import { Value } from "../config/builder/value"
 import { Variants } from "../config/builder/variants"
 import { ValueSpec } from "../config/configTypes"
+import { setupManifest } from "../manifest/setupManifest"
+import { StartSdk } from "../StartSdk"

 describe("builder tests", () => {
  test("text", async () => {
@@ -379,17 +381,61 @@ describe("values", () => {
      })
    })
    test("datetime", async () => {
-      const value = Value.dynamicDatetime<{ test: "a" }>(async ({ utils }) => {
-        ;async () => {
-          ;(await utils.store.getOwn("/test").once()) satisfies "a"
-        }
+      const sdk = StartSdk.of()
+        .withManifest(
+          setupManifest({
+            id: "testOutput",
+            title: "",
+            version: "1.0",
+            releaseNotes: "",
+            license: "",
+            replaces: [],
+            wrapperRepo: "",
+            upstreamRepo: "",
+            supportSite: "",
+            marketingSite: "",
+            donationUrl: null,
+            description: {
+              short: "",
+              long: "",
+            },
+            containers: {},
+            images: [],
+            volumes: [],
+            assets: [],
+            alerts: {
+              install: null,
+              update: null,
+              uninstall: null,
+              restore: null,
+              start: null,
+              stop: null,
+            },
+            dependencies: {
+              remoteTest: {
+                description: "",
+                requirement: { how: "", type: "opt-in" },
+                version: "1.0",
+              },
+            },
+          }),
+        )
+        .withStore<{ test: "a" }>()
+        .build(true)

-        return {
-          name: "Testing",
-          required: { default: null },
-          inputmode: "date",
-        }
-      })
+      const value = Value.dynamicDatetime<{ test: "a" }>(
+        async ({ effects }) => {
+          ;async () => {
+            ;(await sdk.store.getOwn(effects, "/test").once()) satisfies "a"
+          }
+
+          return {
+            name: "Testing",
+            required: { default: null },
+            inputmode: "date",
+          }
+        },
+      )
      const validator = value.validator
      validator.unsafeCast("2021-01-01")
      validator.unsafeCast(null)
--- a/sdk/lib/test/host.test.ts
+++ b/sdk/lib/test/host.test.ts
@@ -1,15 +1,13 @@
 import { ServiceInterfaceBuilder } from "../interfaces/ServiceInterfaceBuilder"
 import { Effects } from "../types"
-import { createUtils } from "../util"
+import { sdk } from "./output.sdk"

 describe("host", () => {
  test("Testing that the types work", () => {
    async function test(effects: Effects) {
-      const utils = createUtils<never, never>(effects)
-      const foo = utils.host.multi("foo")
+      const foo = sdk.host.multi(effects, "foo")
      const fooOrigin = await foo.bindPort(80, {
        protocol: "http" as const,
-        scheme: null,
      })
      const fooInterface = new ServiceInterfaceBuilder({
        effects,
--- a/sdk/lib/test/startosTypeValidation.test.ts
+++ b/sdk/lib/test/startosTypeValidation.test.ts
@@ -13,40 +13,25 @@ import { ExposeUiParams } from "../../../core/startos/bindings/ExposeUiParams"
 import { GetSslCertificateParams } from "../../../core/startos/bindings/GetSslCertificateParams"
 import { GetSslKeyParams } from "../../../core/startos/bindings/GetSslKeyParams"
 import { GetServiceInterfaceParams } from "../../../core/startos/bindings/GetServiceInterfaceParams"
-
+import { SetDependenciesParams } from "../../../core/startos/bindings/SetDependenciesParams"
+import { GetSystemSmtpParams } from "../../../core/startos/bindings/GetSystemSmtpParams"
+import { GetServicePortForwardParams } from "../../../core/startos/bindings/GetServicePortForwardParams"
+import { ExportServiceInterfaceParams } from "../../../core/startos/bindings/ExportServiceInterfaceParams"
+import { GetPrimaryUrlParams } from "../../../core/startos/bindings/GetPrimaryUrlParams"
+import { ListServiceInterfacesParams } from "../../../core/startos/bindings/ListServiceInterfacesParams"
+import { RemoveAddressParams } from "../../../core/startos/bindings/RemoveAddressParams"
+import { ExportActionParams } from "../../../core/startos/bindings/ExportActionParams"
+import { RemoveActionParams } from "../../../core/startos/bindings/RemoveActionParams"
+import { ReverseProxyParams } from "../../../core/startos/bindings/ReverseProxyParams"
+import { MountParams } from "../../../core/startos/bindings/MountParams"
 function typeEquality<ExpectedType>(_a: ExpectedType) {}
 describe("startosTypeValidation ", () => {
  test(`checking the params match`, () => {
    const testInput: any = {}
    typeEquality<{
-      [K in keyof Effects &
-        (
-          | "gitInfo"
-          | "echo"
-          | "chroot"
-          | "exists"
-          | "executeAction"
-          | "getConfigured"
-          | "stopped"
-          | "running"
-          | "restart"
-          | "shutdown"
-          | "setConfigured"
-          | "setMainStatus"
-          | "setHealth"
-          | "getStore"
-          | "setStore"
-          | "exposeForDependents"
-          | "exposeUi"
-          | "createOverlayedImage"
-          | "destroyOverlayedImage"
-          | "getSslCertificate"
-          | "getSslKey"
-          | "getServiceInterface"
-          | "clearBindings"
-          | "bind"
-          | "getHostInfo"
-        )]: Effects[K] extends Function ? Parameters<Effects[K]>[0] : never
+      [K in keyof Effects]: Effects[K] extends (args: infer A) => any
+        ? A
+        : never
    }>({
      executeAction: {} as ExecuteAction,
      createOverlayedImage: {} as CreateOverlayedImageParams,
@@ -57,7 +42,7 @@ describe("startosTypeValidation ", () => {
      exists: {} as ParamsPackageId,
      getConfigured: undefined,
      stopped: {} as ParamsMaybePackageId,
-      running: {} as ParamsMaybePackageId,
+      running: {} as ParamsPackageId,
      restart: undefined,
      shutdown: undefined,
      setConfigured: {} as SetConfigured,
@@ -67,6 +52,20 @@ describe("startosTypeValidation ", () => {
      getSslCertificate: {} as GetSslCertificateParams,
      getSslKey: {} as GetSslKeyParams,
      getServiceInterface: {} as GetServiceInterfaceParams,
+      setDependencies: {} as SetDependenciesParams,
+      store: {} as never,
+      getSystemSmtp: {} as GetSystemSmtpParams,
+      getContainerIp: undefined,
+      getServicePortForward: {} as GetServicePortForwardParams,
+      clearServiceInterfaces: undefined,
+      exportServiceInterface: {} as ExportServiceInterfaceParams,
+      getPrimaryUrl: {} as GetPrimaryUrlParams,
+      listServiceInterfaces: {} as ListServiceInterfacesParams,
+      removeAddress: {} as RemoveAddressParams,
+      exportAction: {} as ExportActionParams,
+      removeAction: {} as RemoveActionParams,
+      reverseProxy: {} as ReverseProxyParams,
+      mount: {} as MountParams,
    })
    typeEquality<Parameters<Effects["executeAction"]>[0]>(
      testInput as ExecuteAction,
--- a/sdk/lib/test/store.test.ts
+++ b/sdk/lib/test/store.test.ts
@@ -1,6 +1,5 @@
+import { MainEffects, StartSdk } from "../StartSdk"
 import { Effects } from "../types"
-import { createMainUtils } from "../util"
-import { createUtils } from "../util/utils"

 type Store = {
  config: {
@@ -12,26 +11,31 @@ const todo = <A>(): A => {
  throw new Error("not implemented")
 }
 const noop = () => {}
+
+const sdk = StartSdk.of()
+  .withManifest({} as Manifest)
+  .withStore<Store>()
+  .build(true)
+
 describe("Store", () => {
  test("types", async () => {
    ;async () => {
-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn("/config", {
+      sdk.store.setOwn(todo<Effects>(), "/config", {
        someValue: "a",
      })
-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn(
-        "/config/someValue",
-        "b",
-      )
-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn("", {
+      sdk.store.setOwn(todo<Effects>(), "/config/someValue", "b")
+      sdk.store.setOwn(todo<Effects>(), "", {
        config: { someValue: "b" },
      })
-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn(
+      sdk.store.setOwn(
+        todo<Effects>(),
        "/config/someValue",

        // @ts-expect-error Type is wrong for the setting value
        5,
      )
-      createUtils(todo<Effects>()).store.setOwn(
+      sdk.store.setOwn(
+        todo<Effects>(),
        // @ts-expect-error Path is wrong
        "/config/someVae3lue",
        "someValue",
@@ -52,49 +56,47 @@ describe("Store", () => {
        path: "/config/some2Value",
        value: "a",
      })
-      ;(await createMainUtils<Manifest, Store>(todo<Effects>())
-        .store.getOwn("/config/someValue")
+      ;(await sdk.store
+        .getOwn(todo<MainEffects>(), "/config/someValue")
        .const()) satisfies string
-      ;(await createMainUtils<Manifest, Store>(todo<Effects>())
-        .store.getOwn("/config")
+      ;(await sdk.store
+        .getOwn(todo<MainEffects>(), "/config")
        .const()) satisfies Store["config"]
-      await createMainUtils(todo<Effects>())
-        // @ts-expect-error Path is wrong
-        .store.getOwn("/config/somdsfeValue")
+      await sdk.store // @ts-expect-error Path is wrong
+        .getOwn(todo<MainEffects>(), "/config/somdsfeValue")
        .const()
      ///  ----------------- ERRORS -----------------

-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn("", {
+      sdk.store.setOwn(todo<MainEffects>(), "", {
        // @ts-expect-error Type is wrong for the setting value
        config: { someValue: "notInAOrB" },
      })
-      createUtils<Manifest, Store>(todo<Effects>()).store.setOwn(
+      sdk.store.setOwn(
+        todo<MainEffects>(),
        "/config/someValue",
        // @ts-expect-error Type is wrong for the setting value
        "notInAOrB",
      )
-      ;(await createUtils<Manifest, Store>(todo<Effects>())
-        .store.getOwn("/config/someValue")
+      ;(await sdk.store
+        .getOwn(todo<Effects>(), "/config/someValue")
        // @ts-expect-error Const should normally not be callable
        .const()) satisfies string
-      ;(await createUtils<Manifest, Store>(todo<Effects>())
-        .store.getOwn("/config")
+      ;(await sdk.store
+        .getOwn(todo<Effects>(), "/config")
        // @ts-expect-error Const should normally not be callable
        .const()) satisfies Store["config"]
-      await createUtils<Manifest, Store>(todo<Effects>())
-        // @ts-expect-error Path is wrong
-        .store.getOwn("/config/somdsfeValue")
+      await sdk.store // @ts-expect-error Path is wrong
+        .getOwn("/config/somdsfeValue")
        // @ts-expect-error Const should normally not be callable
        .const()

      ///
-      ;(await createUtils<Manifest, Store>(todo<Effects>())
-        .store.getOwn("/config/someValue")
+      ;(await sdk.store
+        .getOwn(todo<MainEffects>(), "/config/someValue")
        // @ts-expect-error satisfies type is wrong
        .const()) satisfies number
-      ;(await createMainUtils(todo<Effects>())
-        // @ts-expect-error Path is wrong
-        .store.getOwn("/config/")
+      ;(await sdk.store // @ts-expect-error Path is wrong
+        .getOwn(todo<MainEffects>(), "/config/")
        .const()) satisfies Store["config"]
      ;(await todo<Effects>().store.get<Store, "/config/someValue">({
        path: "/config/someValue",
--- a/sdk/lib/types.ts
+++ b/sdk/lib/types.ts
@@ -1,11 +1,11 @@
 export * as configTypes from "./config/configTypes"
 import { AddSslOptions } from "../../core/startos/bindings/AddSslOptions"
+import { MainEffects, ServiceInterfaceType, Signals } from "./StartSdk"
 import { InputSpec } from "./config/configTypes"
 import { DependenciesReceipt } from "./config/setupConfig"
 import { BindOptions, Scheme } from "./interfaces/Host"
 import { Daemons } from "./mainFn/Daemons"
 import { UrlString } from "./util/getServiceInterface"
-import { ServiceInterfaceType, Signals } from "./util/utils"

 export type ExportedAction = (options: {
  effects: Effects
@@ -59,7 +59,7 @@ export namespace ExpectedExports {
   * package represents, like running a bitcoind in a bitcoind-wrapper.
   */
  export type main = (options: {
-    effects: Effects
+    effects: MainEffects
    started(onTerm: () => PromiseLike<void>): PromiseLike<void>
  }) => Promise<Daemons<any, any>>

@@ -167,7 +167,7 @@ export type ActionMetadata = {
  /**
   * So the ordering of the actions is by alphabetical order of the group, then followed by the alphabetical of the actions
   */
-  group?: string
+  group: string | null
 }
 export declare const hostName: unique symbol
 // asdflkjadsf.onion | 1.2.3.4
@@ -261,24 +261,47 @@ export type ExposeServicePaths<Store = never> = {
  paths: Store extends never ? string[] : ExposeAllServicePaths<Store>[]
 }

-export type ExposeUiPaths<Store> = Array<{
-  /** The path to the value in the Store. [JsonPath](https://jsonpath.com/)  */
-  path: ExposeAllUiPaths<Store>
-  /** A human readable title for the value */
-  title: string
-  /** A human readable description or explanation of the value */
-  description?: string
-  /** (string/number only) Whether or not to mask the value, for example, when displaying a password */
-  masked?: boolean
-  /** (string/number only) Whether or not to include a button for copying the value to clipboard */
-  copyable?: boolean
-  /** (string/number only) Whether or not to include a button for displaying the value as a QR code */
-  qr?: boolean
-}>
+export type ExposeUiPaths<Store> =
+  | {
+      type: "object"
+      value: { [k: string]: ExposeUiPaths<Store> }
+    }
+  | {
+      type: "string"
+      /** The path to the value in the Store. [JsonPath](https://jsonpath.com/)  */
+      path: ExposeAllUiPaths<Store>
+      /** A human readable description or explanation of the value */
+      description?: string
+      /** (string/number only) Whether or not to mask the value, for example, when displaying a password */
+      masked: boolean
+      /** (string/number only) Whether or not to include a button for copying the value to clipboard */
+      copyable?: boolean
+      /** (string/number only) Whether or not to include a button for displaying the value as a QR code */
+      qr?: boolean
+    }
+export type ExposeUiPathsAll =
+  | {
+      type: "object"
+      value: { [k: string]: ExposeUiPathsAll }
+    }
+  | {
+      type: "string"
+      /** The path to the value in the Store. [JsonPath](https://jsonpath.com/)  */
+      path: string
+      /** A human readable description or explanation of the value */
+      description: string | null
+      /** (string/number only) Whether or not to mask the value, for example, when displaying a password */
+      masked: boolean
+      /** (string/number only) Whether or not to include a button for copying the value to clipboard */
+      copyable: boolean | null
+      /** (string/number only) Whether or not to include a button for displaying the value as a QR code */
+      qr: boolean | null
+    }
+
 /** Used to reach out from the pure js runtime */
 export type Effects = {
  executeAction<Input>(opts: {
-    serviceId?: string
+    serviceId: string | null
    input: Input
  }): Promise<unknown>

@@ -286,10 +309,7 @@ export type Effects = {
  createOverlayedImage(options: { imageId: string }): Promise<[string, string]>

  /** A low level api used by destroyOverlay + makeOverlay:destroy */
-  destroyOverlayedImage(options: {
-    imageId: string
-    guid: string
-  }): Promise<void>
+  destroyOverlayedImage(options: { guid: string }): Promise<void>

  /** Removes all network bindings */
  clearBindings(): Promise<void>
@@ -302,8 +322,7 @@ export type Effects = {
    scheme: Scheme
    preferredExternalPort: number
    addSsl: AddSslOptions | null
-    secure: boolean
-    ssl: boolean
+    secure: { ssl: boolean } | null
  }): Promise<void>
  /** Retrieves the current hostname(s) associated with a host id */
  // getHostInfo(options: {
@@ -362,10 +381,10 @@ export type Effects = {
  /**
   * Get the port address for another service
   */
-  getServicePortForward(
-    internalPort: number,
-    packageId?: string,
-  ): Promise<number>
+  getServicePortForward(options: {
+    internalPort: number
+    packageId: string | null
+  }): Promise<number>

  /** Removes all network interfaces */
  clearServiceInterfaces(): Promise<void>
@@ -376,16 +395,7 @@ export type Effects = {

  exposeForDependents(options: { paths: string[] }): Promise<void>

-  exposeUi<Store = never>(options: {
-    paths: {
-      path: string
-      title: string
-      description?: string | undefined
-      masked?: boolean | undefined
-      copyable?: boolean | undefined
-      qr?: boolean | undefined
-    }[]
-  }): Promise<void>
+  exposeUi(options: ExposeUiPathsAll): Promise<void>
  /**
   * There are times that we want to see the addresses that where exported
   * @param options.addressId If we want to filter the address id
@@ -467,7 +477,9 @@ export type Effects = {
  }): Promise<void>

  /** Set the dependencies of what the service needs, usually ran during the set config as a best practice */
-  setDependencies(dependencies: Dependencies): Promise<DependenciesReceipt>
+  setDependencies(options: {
+    dependencies: Dependencies
+  }): Promise<DependenciesReceipt>
  /** Exists could be useful during the runtime to know if some service exists, option dep */
  exists(options: { packageId: PackageId }): Promise<boolean>
  /** Exists could be useful during the runtime to know if some service is running, option dep */
@@ -477,20 +489,20 @@ export type Effects = {
  reverseProxy(options: {
    bind: {
      /** Optional, default is 0.0.0.0 */
-      ip?: string
+      ip: string | null
      port: number
      ssl: boolean
    }
    dst: {
      /** Optional: default is 127.0.0.1 */
-      ip?: string // optional, default 127.0.0.1
+      ip: string | null // optional, default 127.0.0.1
      port: number
      ssl: boolean
    }
-    http?: {
+    http: {
      // optional, will do TCP layer proxy only if not present
-      headers?: (headers: Record<string, string>) => Record<string, string>
-    }
+      headers: Record<string, string> | null
+    } | null
  }): Promise<{ stop(): Promise<void> }>
  restart(): void
  shutdown(): void
@@ -585,7 +597,7 @@ export type KnownError =
 export type Dependency = {
  id: PackageId
  kind: DependencyKind
-}
+} & ({ kind: "exists" } | { kind: "running"; healthChecks: string[] })
 export type Dependencies = Array<Dependency>

 export type DeepPartial<T> = T extends {}
--- a/sdk/lib/util/Overlay.ts
+++ b/sdk/lib/util/Overlay.ts
@@ -64,7 +64,7 @@ export class Overlay {
  async destroy() {
    const imageId = this.imageId
    const guid = this.guid
-    await this.effects.destroyOverlayedImage({ imageId, guid })
+    await this.effects.destroyOverlayedImage({ guid })
  }

  async exec(
--- a/sdk/lib/util/getServiceInterface.ts
+++ b/sdk/lib/util/getServiceInterface.ts
@@ -1,3 +1,4 @@
+import { ServiceInterfaceType } from "../StartSdk"
 import {
  AddressInfo,
  Effects,
@@ -5,7 +6,6 @@ import {
  Hostname,
  HostnameInfo,
 } from "../types"
-import { ServiceInterfaceType } from "./utils"

 export type UrlString = string
 export type HostId = string
--- a/sdk/lib/util/index.ts
+++ b/sdk/lib/util/index.ts
@@ -7,7 +7,6 @@ import "./deepEqual"
 import "./deepMerge"
 import "./Overlay"
 import "./once"
-import * as utils from "./utils"
 import { SDKManifest } from "../manifest/ManifestTypes"

 // prettier-ignore
@@ -23,11 +22,6 @@ export const isKnownError = (e: unknown): e is T.KnownError =>

 declare const affine: unique symbol

-export const createUtils = utils.createUtils
-export const createMainUtils = <Manifest extends SDKManifest, Store>(
-  effects: T.Effects,
-) => createUtils<Manifest, Store, {}>(effects)
-
 type NeverPossible = { [affine]: string }
 export type NoAny<A> = NeverPossible extends A
  ? keyof NeverPossible extends keyof A
--- a/sdk/lib/util/utils.ts
+++ b/sdk/lib/util/utils.ts
@@ -1,300 +0,0 @@
-import nullIfEmpty from "./nullIfEmpty"
-import {
-  CheckResult,
-  checkPortListening,
-  checkWebUrl,
-} from "../health/checkFns"
-import {
-  DaemonReturned,
-  Effects,
-  EnsureStorePath,
-  ExtractStore,
-  ServiceInterfaceId,
-  PackageId,
-  ValidIfNoStupidEscape,
-} from "../types"
-import { GetSystemSmtp } from "./GetSystemSmtp"
-import { GetStore, getStore } from "../store/getStore"
-import { MultiHost, Scheme, SingleHost, StaticHost } from "../interfaces/Host"
-import { ServiceInterfaceBuilder } from "../interfaces/ServiceInterfaceBuilder"
-import { GetServiceInterface, getServiceInterface } from "./getServiceInterface"
-import {
-  GetServiceInterfaces,
-  getServiceInterfaces,
-} from "./getServiceInterfaces"
-import * as CP from "node:child_process"
-import { promisify } from "node:util"
-import { splitCommand } from "./splitCommand"
-import { SDKManifest } from "../manifest/ManifestTypes"
-import { MountOptions, Overlay, CommandOptions } from "./Overlay"
-export type Signals = NodeJS.Signals
-
-export const SIGTERM: Signals = "SIGTERM"
-export const SIGKILL: Signals = "SIGTERM"
-export const NO_TIMEOUT = -1
-
-const childProcess = {
-  exec: promisify(CP.exec),
-  execFile: promisify(CP.execFile),
-}
-const cp = childProcess
-
-export type ServiceInterfaceType = "ui" | "p2p" | "api"
-
-export type Utils<
-  Manifest extends SDKManifest,
-  Store,
-  WrapperOverWrite = { const: never },
-> = {
-  checkPortListening(
-    port: number,
-    options: {
-      errorMessage: string
-      successMessage: string
-      timeoutMessage?: string
-      timeout?: number
-    },
-  ): Promise<CheckResult>
-  checkWebUrl(
-    url: string,
-    options?: {
-      timeout?: number
-      successMessage?: string
-      errorMessage?: string
-    },
-  ): Promise<CheckResult>
-  childProcess: typeof childProcess
-  createInterface: (options: {
-    name: string
-    id: string
-    description: string
-    hasPrimary: boolean
-    disabled: boolean
-    type: ServiceInterfaceType
-    username: null | string
-    path: string
-    search: Record<string, string>
-    schemeOverride: { ssl: Scheme; noSsl: Scheme } | null
-    masked: boolean
-  }) => ServiceInterfaceBuilder
-  getSystemSmtp: () => GetSystemSmtp & WrapperOverWrite
-  host: {
-    static: (id: string) => StaticHost
-    single: (id: string) => SingleHost
-    multi: (id: string) => MultiHost
-  }
-  serviceInterface: {
-    getOwn: (id: ServiceInterfaceId) => GetServiceInterface & WrapperOverWrite
-    get: (opts: {
-      id: ServiceInterfaceId
-      packageId: PackageId
-    }) => GetServiceInterface & WrapperOverWrite
-    getAllOwn: () => GetServiceInterfaces & WrapperOverWrite
-    getAll: (opts: {
-      packageId: PackageId
-    }) => GetServiceInterfaces & WrapperOverWrite
-  }
-  nullIfEmpty: typeof nullIfEmpty
-  runCommand: <A extends string>(
-    imageId: Manifest["images"][number],
-    command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-    options: CommandOptions & {
-      mounts?: { path: string; options: MountOptions }[]
-    },
-  ) => Promise<{ stdout: string | Buffer; stderr: string | Buffer }>
-  runDaemon: <A extends string>(
-    imageId: Manifest["images"][number],
-    command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-    options: CommandOptions & {
-      mounts?: { path: string; options: MountOptions }[]
-      overlay?: Overlay
-    },
-  ) => Promise<DaemonReturned>
-  store: {
-    get: <Path extends string>(
-      packageId: string,
-      path: EnsureStorePath<Store, Path>,
-    ) => GetStore<Store, Path> & WrapperOverWrite
-    getOwn: <Path extends string>(
-      path: EnsureStorePath<Store, Path>,
-    ) => GetStore<Store, Path> & WrapperOverWrite
-    setOwn: <Path extends string | never>(
-      path: EnsureStorePath<Store, Path>,
-      value: ExtractStore<Store, Path>,
-    ) => Promise<void>
-  }
-}
-export const createUtils = <
-  Manifest extends SDKManifest,
-  Store = never,
-  WrapperOverWrite = { const: never },
->(
-  effects: Effects,
-): Utils<Manifest, Store, WrapperOverWrite> => {
-  return {
-    createInterface: (options: {
-      name: string
-      id: string
-      description: string
-      hasPrimary: boolean
-      disabled: boolean
-      type: ServiceInterfaceType
-      username: null | string
-      path: string
-      search: Record<string, string>
-      schemeOverride: { ssl: Scheme; noSsl: Scheme } | null
-      masked: boolean
-    }) => new ServiceInterfaceBuilder({ ...options, effects }),
-    childProcess,
-    getSystemSmtp: () =>
-      new GetSystemSmtp(effects) as GetSystemSmtp & WrapperOverWrite,
-
-    host: {
-      static: (id: string) => new StaticHost({ id, effects }),
-      single: (id: string) => new SingleHost({ id, effects }),
-      multi: (id: string) => new MultiHost({ id, effects }),
-    },
-    nullIfEmpty,
-
-    serviceInterface: {
-      getOwn: (id: ServiceInterfaceId) =>
-        getServiceInterface(effects, {
-          id,
-          packageId: null,
-        }) as GetServiceInterface & WrapperOverWrite,
-      get: (opts: { id: ServiceInterfaceId; packageId: PackageId }) =>
-        getServiceInterface(effects, opts) as GetServiceInterface &
-          WrapperOverWrite,
-      getAllOwn: () =>
-        getServiceInterfaces(effects, {
-          packageId: null,
-        }) as GetServiceInterfaces & WrapperOverWrite,
-      getAll: (opts: { packageId: PackageId }) =>
-        getServiceInterfaces(effects, opts) as GetServiceInterfaces &
-          WrapperOverWrite,
-    },
-    store: {
-      get: <Path extends string = never>(
-        packageId: string,
-        path: EnsureStorePath<Store, Path>,
-      ) =>
-        getStore<Store, Path>(effects, path as any, {
-          packageId,
-        }) as any,
-      getOwn: <Path extends string>(path: EnsureStorePath<Store, Path>) =>
-        getStore<Store, Path>(effects, path as any) as any,
-      setOwn: <Path extends string | never>(
-        path: EnsureStorePath<Store, Path>,
-        value: ExtractStore<Store, Path>,
-      ) => effects.store.set<Store, Path>({ value, path: path as any }),
-    },
-
-    runCommand: async <A extends string>(
-      imageId: Manifest["images"][number],
-      command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-      options: CommandOptions & {
-        mounts?: { path: string; options: MountOptions }[]
-      },
-    ): Promise<{ stdout: string | Buffer; stderr: string | Buffer }> => {
-      const commands = splitCommand(command)
-      const overlay = await Overlay.of(effects, imageId)
-      try {
-        for (let mount of options.mounts || []) {
-          await overlay.mount(mount.options, mount.path)
-        }
-        return await overlay.exec(commands)
-      } finally {
-        await overlay.destroy()
-      }
-    },
-    runDaemon: async <A extends string>(
-      imageId: Manifest["images"][number],
-      command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-      options: CommandOptions & {
-        mounts?: { path: string; options: MountOptions }[]
-        overlay?: Overlay
-      },
-    ): Promise<DaemonReturned> => {
-      const commands = splitCommand(command)
-      const overlay = options.overlay || (await Overlay.of(effects, imageId))
-      for (let mount of options.mounts || []) {
-        await overlay.mount(mount.options, mount.path)
-      }
-      const childProcess = await overlay.spawn(commands, {
-        env: options.env,
-      })
-      const answer = new Promise<null>((resolve, reject) => {
-        childProcess.stdout.on("data", (data: any) => {
-          console.log(data.toString())
-        })
-        childProcess.stderr.on("data", (data: any) => {
-          console.error(data.toString())
-        })
-
-        childProcess.on("exit", (code: any) => {
-          if (code === 0) {
-            return resolve(null)
-          }
-          return reject(new Error(`${commands[0]} exited with code ${code}`))
-        })
-      })
-
-      const pid = childProcess.pid
-      return {
-        async wait() {
-          const pids = pid ? await psTree(pid, overlay) : []
-          try {
-            return await answer
-          } finally {
-            for (const process of pids) {
-              cp.execFile("kill", [`-9`, String(process)]).catch((_) => {})
-            }
-          }
-        },
-        async term({ signal = SIGTERM, timeout = NO_TIMEOUT } = {}) {
-          const pids = pid ? await psTree(pid, overlay) : []
-          try {
-            childProcess.kill(signal)
-
-            if (timeout > NO_TIMEOUT) {
-              const didTimeout = await Promise.race([
-                new Promise((resolve) => setTimeout(resolve, timeout)).then(
-                  () => true,
-                ),
-                answer.then(() => false),
-              ])
-              if (didTimeout) {
-                childProcess.kill(SIGKILL)
-              }
-            } else {
-              await answer
-            }
-          } finally {
-            await overlay.destroy()
-          }
-
-          try {
-            for (const process of pids) {
-              await cp.execFile("kill", [`-${signal}`, String(process)])
-            }
-          } finally {
-            for (const process of pids) {
-              cp.execFile("kill", [`-9`, String(process)]).catch((_) => {})
-            }
-          }
-        },
-      }
-    },
-    checkPortListening: checkPortListening.bind(null, effects),
-    checkWebUrl: checkWebUrl.bind(null, effects),
-  }
-}
-function noop(): void {}
-
-async function psTree(pid: number, overlay: Overlay): Promise<number[]> {
-  const { stdout } = await childProcess.exec(`pstree -p ${pid}`)
-  const regex: RegExp = /\((\d+)\)/g
-  return [...stdout.toString().matchAll(regex)].map(([_all, pid]) =>
-    parseInt(pid),
-  )
-}
--- a/sdk/package.json
+++ b/sdk/package.json
@@ -2,15 +2,15 @@
  "name": "@start9labs/start-sdk",
  "version": "0.4.0-rev0.lib0.rc8.beta10",
  "description": "Software development kit to facilitate packaging services for StartOS",
-  "main": "./cjs/lib/index.js",
-  "types": "./cjs/lib/index.d.ts",
-  "module": "./mjs/lib/index.js",
+  "main": "./cjs/sdk/lib/index.js",
+  "types": "./cjs/sdk/lib/index.d.ts",
+  "module": "./mjs/sdk/lib/index.js",
  "sideEffects": true,
  "exports": {
    ".": {
-      "import": "./mjs/lib/index.js",
-      "require": "./cjs/lib/index.js",
-      "types": "./cjs/lib/index.d.ts"
+      "import": "./mjs/sdk/lib/index.js",
+      "require": "./cjs/sdk/lib/index.js",
+      "types": "./cjs/sdk/lib/index.d.ts"
    }
  },
  "typesVersion": {
@@ -56,4 +56,4 @@
    "tsx": "^4.7.1",
    "typescript": "^5.0.4"
  }
-}
+}