feat: Add in overlay

lib/util/Overlay.ts

@@ -0,0 +1,92 @@
+import fs from "fs/promises"
+import * as T from "../types"
+import cp from "child_process"
+import { promisify } from "util"
+import { Buffer } from "node:buffer"
+export const execFile = promisify(cp.execFile)
+
+export class Overlay {
+  private constructor(readonly effects: T.Effects, readonly rootfs: string) {}
+  static async of(effects: T.Effects, imageId: string) {
+    const rootfs = await effects.createOverlayedImage({ imageId })
+
+    for (const dirPart of ["dev", "sys", "proc", "run"] as const) {
+      const dir = await fs.mkdir(`${rootfs}/${dirPart}`, { recursive: true })
+      if (!dir) break
+      await execFile("mount", ["--bind", `/${dirPart}`, dir])
+    }
+
+    return new Overlay(effects, rootfs)
+  }
+
+  async mount(options: MountOptions, path: string): Promise<Overlay> {
+    path = path.startsWith("/")
+      ? `${this.rootfs}${path}`
+      : `${this.rootfs}/${path}`
+    if (options.type === "volume") {
+      await execFile("mount", [
+        "--bind",
+        `/media/startos/volumes/${options.id}`,
+        path,
+      ])
+    } else if (options.type === "assets") {
+      await execFile("mount", [
+        "--bind",
+        `/media/startos/assets/${options.id}`,
+        path,
+      ])
+    } else if (options.type === "pointer") {
+      await this.effects.mount({ location: path, target: options })
+    } else {
+      throw new Error(`unknown type ${(options as any).type}`)
+    }
+    return this
+  }
+
+  async destroy() {
+    await execFile("umount", ["-R", this.rootfs])
+    await fs.rm(this.rootfs, { recursive: true, force: true })
+  }
+
+  async exec(
+    command: string[],
+    options?: CommandOptions,
+  ): Promise<{ stdout: string | Buffer; stderr: string | Buffer }> {
+    return await execFile("chroot", [this.rootfs, ...command], options)
+  }
+
+  spawn(
+    command: string[],
+    options?: CommandOptions,
+  ): cp.ChildProcessWithoutNullStreams {
+    return cp.spawn("chroot", [this.rootfs, ...command], options)
+  }
+}
+
+export type CommandOptions = {
+  env?: { [variable: string]: string }
+  cwd?: string
+}
+
+export type MountOptions =
+  | MountOptionsVolume
+  | MountOptionsAssets
+  | MountOptionsPointer
+
+export type MountOptionsVolume = {
+  type: "volume"
+  id: string
+}
+
+export type MountOptionsAssets = {
+  type: "assets"
+  id: string
+}
+
+export type MountOptionsPointer = {
+  type: "pointer"
+  packageId: string
+  volumeId: string
+  path: string
+  readonly: boolean
+}

lib/util/index.ts

@@ -5,8 +5,10 @@ import "./fileHelper"
 import "../store/getStore"
 import "./deepEqual"
 import "./deepMerge"
+import "./Overlay"
 import "./once"
 import { utils } from "./utils"
+import { SDKManifest } from "../manifest/ManifestTypes"
 
 // prettier-ignore
 export type FlattenIntersection<T> = 
@@ -22,8 +24,9 @@ export const isKnownError = (e: unknown): e is T.KnownError =>
 declare const affine: unique symbol
 
 export const createUtils = utils
-export const createMainUtils = <Store>(effects: T.Effects) =>
-  createUtils<Store, {}>(effects)
+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

lib/util/utils.ts

@@ -37,6 +37,8 @@ import {
 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"
@@ -50,7 +52,11 @@ const childProcess = {
 
 export type NetworkInterfaceType = "ui" | "p2p" | "api" | "other"
 
-export type Utils<Store, WrapperOverWrite = { const: never }> = {
+export type Utils<
+  Manifest extends SDKManifest,
+  Store,
+  WrapperOverWrite = { const: never },
+> = {
   checkPortListening(
     port: number,
     options: {
@@ -107,9 +113,19 @@ export type Utils<Store, WrapperOverWrite = { const: never }> = {
     }) => GetNetworkInterfaces & WrapperOverWrite
   }
   nullIfEmpty: typeof nullIfEmpty
-  runDaemon: <A extends string>(
+  runCommand: <A extends string>(
+    imageId: Manifest["images"][number],
     command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-    options: { env?: Record<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 }[]
+    },
   ) => Promise<DaemonReturned>
   store: {
     get: <Path extends string>(
@@ -125,9 +141,13 @@ export type Utils<Store, WrapperOverWrite = { const: never }> = {
     ) => Promise<void>
   }
 }
-export const utils = <Store = never, WrapperOverWrite = { const: never }>(
+export const utils = <
+  Manifest extends SDKManifest,
+  Store = never,
+  WrapperOverWrite = { const: never },
+>(
   effects: Effects,
-): Utils<Store, WrapperOverWrite> => {
+): Utils<Manifest, Store, WrapperOverWrite> => {
   return {
     createInterface: (options: {
       name: string
@@ -181,12 +201,39 @@ export const utils = <Store = never, WrapperOverWrite = { const: never }>(
       ) => effects.store.set<Store, Path>({ value, path: path as any }),
     },
 
-    runDaemon: async <A extends string>(
+    runCommand: async <A extends string>(
+      imageId: Manifest["images"][number],
       command: ValidIfNoStupidEscape<A> | [string, ...string[]],
-      options: { env?: Record<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 }[]
+      },
     ): Promise<DaemonReturned> => {
       const commands = splitCommand(command)
-      const childProcess = CP.spawn(commands[0], commands.slice(1), options)
+      const overlay = await Overlay.of(effects, imageId)
+      for (let mount of options.mounts || []) {
+        await overlay.mount(mount.options, mount.path)
+      }
+      const childProcess = overlay.spawn(commands, {
+        env: options.env,
+      })
       const answer = new Promise<string>((resolve, reject) => {
         const output: string[] = []
         childProcess.stdout.on("data", (data) => {
@@ -210,18 +257,22 @@ export const utils = <Store = never, WrapperOverWrite = { const: never }>(
           return answer
         },
         async term({ signal = SIGTERM, timeout = NO_TIMEOUT } = {}) {
-          childProcess.kill(signal)
+          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)
+            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)
+            }
+            await answer
+          } finally {
+            await overlay.destroy()
           }
-          await answer
         },
       }
     },