@highstate/backend 0.9.14 → 0.9.16

package/src/terminal/docker.ts

@@ -1,4 +1,4 @@
-import type { TerminalRunOptions, TerminalBackend } from "./shared"
+import type { TerminalRunOptions, TerminalBackend } from "./abstractions"
 import type { Logger } from "pino"
 import { Readable } from "node:stream"
 import { tmpdir } from "node:os"
@@ -9,9 +9,9 @@ import spawn from "nano-spawn"
 import { runScript } from "./run.sh"
 
 export const dockerTerminalBackendConfig = z.object({
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: z.string().default("docker"),
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_USE_SUDO: z.coerce.boolean().default(false),
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST: z.string().optional(),
+  HIGHSTATE_TERMINAL_BACKEND_DOCKER_BINARY: z.string().default("docker"),
+  HIGHSTATE_TERMINAL_BACKEND_DOCKER_USE_SUDO: z.coerce.boolean().default(false),
+  HIGHSTATE_TERMINAL_BACKEND_DOCKER_HOST: z.string().optional(),
 })
 
 export class DockerTerminalBackend implements TerminalBackend {
@@ -22,7 +22,7 @@ export class DockerTerminalBackend implements TerminalBackend {
     private readonly logger: Logger,
   ) {}
 
-  async run({ factory, stdin, stdout, screenSize, signal }: TerminalRunOptions): Promise<void> {
+  async run({ spec, stdin, stdout, screenSize, signal }: TerminalRunOptions): Promise<void> {
     const hsTempDir = resolve(tmpdir(), "highstate")
     await mkdir(hsTempDir, { recursive: true })
 
@@ -34,19 +34,19 @@ export class DockerTerminalBackend implements TerminalBackend {
       "-i",
       "-v",
       `${runScriptPath}:/run.sh:ro`,
-      factory.image,
+      spec.image,
       "/bin/bash",
       "/run.sh",
     ]
 
     const initData = {
-      command: factory.command,
-      cwd: factory.cwd,
+      command: spec.command,
+      cwd: spec.cwd,
       env: {
-        ...factory.env,
+        ...spec.env,
         TERM: "xterm-256color",
       },
-      files: factory.files ?? {},
+      files: spec.files ?? {},
       screenSize,
     }
 
@@ -71,7 +71,11 @@ export class DockerTerminalBackend implements TerminalBackend {
     childProcess.stdout!.pipe(stdout)
     childProcess.stderr!.pipe(stdout)
 
-    this.logger.info({ pid: childProcess.pid }, "process started")
+    if (!childProcess.pid) {
+      throw new Error(`Failed to start Docker container without clear response from child process.`)
+    }
+
+    this.logger.info({ processId: childProcess.pid }, "process started")
 
     await process
   }
@@ -81,9 +85,9 @@ export class DockerTerminalBackend implements TerminalBackend {
     logger: Logger,
   ): DockerTerminalBackend {
     return new DockerTerminalBackend(
-      config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY,
-      config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_USE_SUDO,
-      config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST,
+      config.HIGHSTATE_TERMINAL_BACKEND_DOCKER_BINARY,
+      config.HIGHSTATE_TERMINAL_BACKEND_DOCKER_USE_SUDO,
+      config.HIGHSTATE_TERMINAL_BACKEND_DOCKER_HOST,
       logger.child({ backend: "TerminalBackend", service: "DockerTerminalBackend" }),
     )
   }

package/src/terminal/factory.ts

@@ -1,10 +1,10 @@
 import type { Logger } from "pino"
-import type { TerminalBackend } from "./shared"
+import type { TerminalBackend } from "./abstractions"
 import { z } from "zod"
 import { DockerTerminalBackend, dockerTerminalBackendConfig } from "./docker"
 
 export const terminalBackendConfig = z.object({
-  HIGHSTATE_BACKEND_TERMINAL_TYPE: z.enum(["docker"]).default("docker"),
+  HIGHSTATE_TERMINAL_BACKEND_TYPE: z.enum(["docker"]).default("docker"),
   ...dockerTerminalBackendConfig.shape,
 })
 
@@ -12,7 +12,7 @@ export function createTerminalBackend(
   config: z.infer<typeof terminalBackendConfig>,
   logger: Logger,
 ): TerminalBackend {
-  switch (config.HIGHSTATE_BACKEND_TERMINAL_TYPE) {
+  switch (config.HIGHSTATE_TERMINAL_BACKEND_TYPE) {
     case "docker": {
       return DockerTerminalBackend.create(config, logger)
     }

package/src/terminal/index.ts

@@ -1,3 +1,3 @@
-export * from "./shared"
+export * from "./abstractions"
 export * from "./factory"
 export * from "./manager"

package/src/terminal/manager.ts

@@ -1,12 +1,16 @@
-import type { ScreenSize, TerminalBackend } from "./shared"
+import type { ScreenSize, TerminalBackend } from "./abstractions"
 import type { Logger } from "pino"
-import type { StateBackend, TerminalHistoryEntry } from "../state"
-import type { RunnerBackend } from "../runner"
+import type { PubSubManager } from "../pubsub"
+import type { ProjectUnlockService } from "../business"
+import type { StateManager } from "../state"
 import { PassThrough, type Stream, type Writable } from "node:stream"
-import { EventEmitter, on } from "node:events"
-import { parseInstanceId } from "@highstate/contract"
-import { nanoid } from "nanoid"
-import { type InstanceTerminal, type TerminalSession, createAsyncBatcher } from "../shared"
+import { v7 as uuidv7 } from "uuid"
+import {
+  type TerminalSession,
+  type TerminalSpec,
+  createAsyncBatcher,
+  type AsyncBatcher,
+} from "../shared"
 import { isAbortErrorLike } from "../common"
 
 type ManagedTerminal = {
@@ -14,30 +18,31 @@ type ManagedTerminal = {
   readonly abortController: AbortController
   readonly stdin: PassThrough
   readonly stdout: PassThrough
+  readonly logBatcher: AsyncBatcher<string>
 
   refCount: number
   started: boolean
   start(screenSize: ScreenSize): void
 }
 
-type TerminalEvents = {
-  [sessionId: string]: [terminal: TerminalSession]
-}
-
 const notAttachedTerminalLifetime = 5 * 60 * 1000 // 5 minutes
 
 export class TerminalManager {
   private readonly managedTerminals = new Map<string, ManagedTerminal>()
   private readonly existingSessions = new Map<string, TerminalSession>()
-  private readonly terminalEE = new EventEmitter<TerminalEvents>()
 
   private constructor(
     private readonly terminalBackend: TerminalBackend,
-    private readonly stateBackend: StateBackend,
-    private readonly runnerBackend: RunnerBackend,
+    private readonly stateManager: StateManager,
+    private readonly pubsubManager: PubSubManager,
+    private readonly projectUnlockService: ProjectUnlockService,
     private readonly logger: Logger,
   ) {
-    void this.markFinishedSessions()
+    this.projectUnlockService.registerUnlockTask(
+      //
+      "mark-finished-terminal-sessions",
+      projectId => this.markFinishedSessions(projectId),
+    )
   }
 
   public isSessionActive(sessionId: string): boolean {
@@ -46,7 +51,6 @@ export class TerminalManager {
 
   public async *watchSession(
     projectId: string,
-    instanceId: string,
     sessionId: string,
     signal?: AbortSignal,
   ): AsyncIterable<TerminalSession> {
@@ -54,7 +58,7 @@ export class TerminalManager {
 
     // if terminal session is not active, just fetch it, return and stop watching
     if (!managedTerminal) {
-      const session = await this.stateBackend.getTerminalSession(projectId, instanceId, sessionId)
+      const session = await this.stateManager.getTerminalSessionRepository(projectId).get(sessionId)
 
       if (!session) {
         throw new Error(`Terminal session "${sessionId}" not found`)
@@ -66,65 +70,86 @@ export class TerminalManager {
 
     yield managedTerminal.session
 
-    for await (const [terminalSession] of on(this.terminalEE, sessionId, {
+    for await (const terminalSession of this.pubsubManager.subscribe(
+      ["active-terminal-session", projectId, sessionId],
       signal,
-    }) as AsyncIterable<[TerminalSession]>) {
+    )) {
       yield terminalSession
 
-      if (terminalSession.finishedAt) {
+      if (terminalSession.meta.finishedAt) {
         // terminal session is finished, stop watching
         return
       }
     }
   }
 
-  public async createSession(
-    projectId: string,
-    instanceId: string,
-    terminalName: string,
-  ): Promise<TerminalSession> {
-    const [instanceType, instanceName] = parseInstanceId(instanceId)
-
-    const factory = await this.runnerBackend.getTerminalFactory(
-      { projectId, instanceType, instanceName },
-      terminalName,
-    )
+  public async createSession(projectId: string, terminalId: string): Promise<TerminalSession> {
+    // Get the terminal info from info repository for meta data
+    const terminalInfoRepo = this.stateManager.getTerminalRepository(projectId)
+    const terminal = await terminalInfoRepo.get(terminalId)
 
-    if (!factory) {
-      throw new Error(
-        `Terminal factory for instance "${instanceId}" with name "${terminalName}" not found`,
-      )
+    if (!terminal) {
+      throw new Error(`Terminal "${terminalId}" not found`)
     }
 
     const terminalSession: TerminalSession = {
-      id: nanoid(),
+      id: uuidv7(),
       projectId,
-      instanceId,
-      terminalName,
-      terminalTitle: factory.title,
-      createdAt: new Date(),
+      instanceId: terminal.instanceId,
+      terminalId,
+      meta: {
+        title: terminal.meta.title,
+        description: terminal.meta.description,
+        icon: terminal.meta.icon,
+      },
     }
 
-    await this.stateBackend.putTerminalSession(projectId, instanceId, terminalSession)
+    // Get the terminal spec for execution
+    const terminalSpec = await this.stateManager
+      .getTerminalSpecRepository(projectId)
+      .get(terminalId)
+
+    if (!terminalSpec) {
+      throw new Error(`No spec found for terminal "${terminalId}"`)
+    }
+
+    const batch = this.stateManager.batch()
+    const promises: Promise<void>[] = [
+      this.stateManager.getTerminalSessionRepository(projectId).putItem(terminalSession, batch),
+      this.stateManager
+        .getActiveTerminalSessionIndexRepository(projectId)
+        .indexRepository.put(terminalSession.id, terminalSession.id, batch),
+    ]
+
+    if (terminal.instanceId) {
+      promises.push(
+        this.stateManager
+          .getInstanceTerminalSessionIndexRepository(projectId, terminal.instanceId)
+          .indexRepository.put(terminalSession.id, terminalSession.id, batch),
+      )
+    }
+
+    await Promise.allSettled(promises)
+    await batch.write()
     this.logger.info({ msg: "terminal session created", id: terminalSession.id })
 
-    this.createManagedTerminal(factory, terminalSession)
+    this.createManagedTerminal(terminalSpec, terminalSession)
 
     return terminalSession
   }
 
   public async getOrCreateSession(
     projectId: string,
-    instanceId: string,
-    terminalName: string,
+    terminalId: string,
+    newSession = false,
   ): Promise<TerminalSession> {
-    const existingSession = this.existingSessions.get(`${projectId}:${instanceId}.${terminalName}`)
+    const existingSession = this.existingSessions.get(`${projectId}:${terminalId}`)
 
-    if (existingSession) {
+    if (existingSession && !newSession) {
       return existingSession
     }
 
-    return await this.createSession(projectId, instanceId, terminalName)
+    return await this.createSession(projectId, terminalId)
   }
 
   public close(sessionId: string): void {
@@ -187,13 +212,11 @@ export class TerminalManager {
   }
 
   private async updateActiveTerminalSessions(): Promise<void> {
-    await this.stateBackend.putActiveTerminalSessions(
-      Array.from(this.managedTerminals.values()).map(t => t.session),
-    )
+    // TODO
   }
 
   private createManagedTerminal(
-    factory: InstanceTerminal,
+    spec: TerminalSpec,
     terminalSession: TerminalSession,
   ): ManagedTerminal {
     const managedTerminal: ManagedTerminal = {
@@ -202,13 +225,21 @@ export class TerminalManager {
       stdin: new PassThrough(),
       stdout: new PassThrough(),
 
+      logBatcher: createAsyncBatcher(async (entries: string[]) => {
+        this.logger.trace({ msg: "persisting terminal log entries", count: entries.length })
+
+        await this.stateManager
+          .getTerminalSessionLineRepository(terminalSession.projectId, terminalSession.id)
+          .putMany(entries.map(entry => [uuidv7(), entry]))
+      }),
+
       refCount: 0,
       started: false,
 
       start: (screenSize: ScreenSize) => {
         void this.terminalBackend
           .run({
-            factory,
+            spec,
             stdin: managedTerminal.stdin,
             stdout: managedTerminal.stdout,
             screenSize,
@@ -229,19 +260,25 @@ export class TerminalManager {
             this.logger.info({ msg: "managed terminal closed", id: managedTerminal.session.id })
             this.managedTerminals.delete(managedTerminal.session.id)
             this.existingSessions.delete(
-              `${managedTerminal.session.projectId}:${managedTerminal.session.instanceId}.${managedTerminal.session.terminalName}`,
+              `${managedTerminal.session.projectId}:${managedTerminal.session.terminalId}`,
             )
 
-            managedTerminal.session.finishedAt = new Date()
-            this.terminalEE.emit(managedTerminal.session.id, managedTerminal.session)
-
-            void this.stateBackend.putTerminalSession(
-              managedTerminal.session.projectId,
-              managedTerminal.session.instanceId,
+            managedTerminal.session.meta.finishedAt = Date.now()
+            void this.pubsubManager.publish(
+              [
+                "active-terminal-session",
+                managedTerminal.session.projectId,
+                managedTerminal.session.id,
+              ],
               managedTerminal.session,
             )
 
+            void this.stateManager
+              .getTerminalSessionRepository(managedTerminal.session.projectId)
+              .putItem(managedTerminal.session)
+
             void this.updateActiveTerminalSessions()
+            void managedTerminal.logBatcher.flush()
           })
 
         setTimeout(
@@ -256,12 +293,12 @@ export class TerminalManager {
     managedTerminal.stdout.on("data", data => {
       const entry = String(data)
 
-      void this.persistHistory.call([terminalSession.id, entry])
+      managedTerminal.logBatcher.call(entry)
     })
 
     this.managedTerminals.set(managedTerminal.session.id, managedTerminal)
     this.existingSessions.set(
-      `${managedTerminal.session.projectId}:${managedTerminal.session.instanceId}.${managedTerminal.session.terminalName}`,
+      `${managedTerminal.session.projectId}:${managedTerminal.session.terminalId}`,
       managedTerminal.session,
     )
 
@@ -284,9 +321,7 @@ export class TerminalManager {
 
       terminal.abortController.abort()
       this.managedTerminals.delete(terminal.session.id)
-      this.existingSessions.delete(
-        `${terminal.session.projectId}:${terminal.session.instanceId}.${terminal.session.terminalName}`,
-      )
+      this.existingSessions.delete(`${terminal.session.projectId}:${terminal.session.terminalId}`)
       return
     }
 
@@ -295,36 +330,55 @@ export class TerminalManager {
 
   static create(
     terminalBackend: TerminalBackend,
-    stateBackend: StateBackend,
-    runnerBackend: RunnerBackend,
+    stateBackend: StateManager,
+    pubsubManager: PubSubManager,
+    projectUnlockService: ProjectUnlockService,
     logger: Logger,
   ): TerminalManager {
     return new TerminalManager(
       terminalBackend,
       stateBackend,
-      runnerBackend,
+      pubsubManager,
+      projectUnlockService,
       logger.child({ service: "TerminalManager" }),
     )
   }
 
-  private persistHistory = createAsyncBatcher(async (entries: TerminalHistoryEntry[]) => {
-    this.logger.trace({ msg: "persisting history entries", count: entries.length })
+  private async markFinishedSessions(projectId: string): Promise<void> {
+    const activeSessions = await this.stateManager
+      .getActiveTerminalSessionIndexRepository(projectId)
+      .getAllItems()
 
-    // TODO: buffer entries and save them as lines
+    if (activeSessions.length === 0) {
+      this.logger.debug({ projectId }, "no lost terminal sessions found")
+      return
+    }
 
-    await this.stateBackend.appendTerminalSessionHistory(entries)
-  })
+    const batch = this.stateManager.batch()
 
-  private async markFinishedSessions(): Promise<void> {
-    const sessions = await this.stateBackend.getActiveTerminalSessions()
+    for (const session of activeSessions) {
+      if (session.meta.finishedAt) {
+        // Already marked as finished
+        this.logger.debug({ sessionId: session.id }, "session already marked as finished")
+        continue
+      }
 
-    for (const session of sessions) {
-      await this.stateBackend.putTerminalSession(session.projectId, session.instanceId, {
-        ...session,
-        finishedAt: new Date(),
-      })
+      session.meta.finishedAt = Date.now()
+
+      // mark session as finished and delete from active index
+      await Promise.all([
+        this.stateManager.getTerminalSessionRepository(projectId).putItem(session, batch),
+        this.stateManager
+          .getActiveTerminalSessionIndexRepository(projectId)
+          .indexRepository.delete(session.id, batch),
+      ])
     }
 
-    await this.updateActiveTerminalSessions()
+    await batch.write()
+
+    this.logger.debug(
+      { projectId, count: activeSessions.length },
+      "marked terminal sessions as finished",
+    )
   }
 }

package/src/terminal/run.sh.ts

@@ -16,18 +16,30 @@ done
 
 # Create files
 for key in "\${filesKeys[@]}"; do
-  isBinary=$(jq -r ".files[\\"$key\\"].isBinary // false" <<<"$data")
-  content=$(jq -r ".files[\\"$key\\"].content" <<<"$data")
-  mode=$(jq -r ".files[\\"$key\\"].mode // 0" <<<"$data")
-
-  if [ "$isBinary" = "true" ]; then
-    echo "$content" | base64 -d > "$key"
-  else
-    echo "$content" > "$key"
+  contentType=$(jq -r ".files[\\"$key\\"].content.type" <<<"$data")
+  
+  # Skip artifact type files for now
+  if [ "$contentType" = "artifact" ]; then
+    continue
   fi
+  
+  # Handle embedded content
+  if [ "$contentType" = "embedded" ]; then
+    content=$(jq -r ".files[\\"$key\\"].content.value" <<<"$data")
+    isBinary=$(jq -r ".files[\\"$key\\"].meta.isBinary // false" <<<"$data")
+    mode=$(jq -r ".files[\\"$key\\"].meta.mode // 0" <<<"$data")
+    
+    mkdir -p "$(dirname "$key")"
+
+    if [ "$isBinary" = "true" ]; then
+      echo "$content" | base64 -d > "$key"
+    else
+      echo "$content" > "$key"
+    fi
 
-  if [ "$mode" -ne 0 ]; then
-    chmod $(printf "%o" "$mode") "$key"
+    if [ "$mode" -ne 0 ]; then
+      chmod $(printf "%o" "$mode") "$key"
+    fi
   fi
 done
 

package/src/worker/abstractions.ts

@@ -0,0 +1,42 @@
+import type { Worker } from "../shared"
+
+export type WorkerRunOptions = {
+  /**
+   * The ID of the project to run the worker for.
+   */
+  projectId: string
+
+  /**
+   * The worker to run.
+   */
+  worker: Worker
+
+  /**
+   * The token of the API key to pass to the worker.
+   */
+  apiKey: string
+
+  /**
+   * The path of the API socket to pass to the worker.
+   */
+  apiPath: string
+
+  /**
+   * The output stream.
+   */
+  stdout: NodeJS.WritableStream
+
+  /**
+   * The signal to abort the worker.
+   */
+  signal?: AbortSignal
+}
+
+export interface WorkerBackend {
+  /**
+   * Runs a worker with the given options.
+   *
+   * @param options The options.
+   */
+  run(options: WorkerRunOptions): Promise<void>
+}

package/src/worker/docker.ts

@@ -0,0 +1,83 @@
+import type { Logger } from "pino"
+import type { WorkerBackend, WorkerRunOptions } from "./abstractions"
+import { Readable } from "node:stream"
+import { z } from "zod"
+import spawn from "nano-spawn"
+
+export const dockerWorkerBackendConfig = z.object({
+  HIGHSTATE_WORKER_BACKEND_DOCKER_BINARY: z.string().default("docker"),
+  HIGHSTATE_WORKER_BACKEND_DOCKER_USE_SUDO: z.coerce.boolean().default(false),
+  HIGHSTATE_WORKER_BACKEND_DOCKER_HOST: z.string().optional(),
+})
+
+export class DockerWorkerBackend implements WorkerBackend {
+  constructor(
+    private readonly binary: string,
+    private readonly useSudo: boolean,
+    private readonly host: string | undefined,
+    private readonly logger: Logger,
+  ) {}
+
+  async run({
+    projectId,
+    worker,
+    apiKey,
+    apiPath,
+    stdout,
+    signal,
+  }: WorkerRunOptions): Promise<void> {
+    const args = [
+      "run",
+      "-i",
+      "-v",
+      `${apiPath}:/var/run/highstate.sock`,
+      worker.image,
+      "/bin/bash",
+      "/run.sh",
+    ]
+
+    const initData = {
+      projectId,
+      workerId: worker.id,
+      apiKey,
+      apiUrl: "/var/run/highstate.sock",
+    }
+
+    const initDataStream = Readable.from(JSON.stringify(initData) + "\n")
+
+    if (this.useSudo) {
+      args.unshift(this.binary)
+    }
+
+    const process = spawn(this.useSudo ? "sudo" : this.binary, args, {
+      env: {
+        DOCKER_HOST: this.host,
+      },
+      signal,
+    })
+
+    const childProcess = await process.nodeChildProcess
+
+    initDataStream.pipe(childProcess.stdin!)
+
+    childProcess.stdout!.pipe(stdout)
+    childProcess.stderr!.pipe(stdout)
+
+    if (!childProcess.pid) {
+      throw new Error(`Failed to start Docker container without clear response from child process.`)
+    }
+
+    this.logger.info({ processId: childProcess.pid }, "process started")
+
+    await process
+  }
+
+  static create(config: z.infer<typeof dockerWorkerBackendConfig>, logger: Logger): WorkerBackend {
+    return new DockerWorkerBackend(
+      config.HIGHSTATE_WORKER_BACKEND_DOCKER_BINARY,
+      config.HIGHSTATE_WORKER_BACKEND_DOCKER_USE_SUDO,
+      config.HIGHSTATE_WORKER_BACKEND_DOCKER_HOST,
+      logger.child({ backend: "WorkerBackend", service: "DockerWorkerBackend" }),
+    )
+  }
+}

package/src/worker/factory.ts

@@ -0,0 +1,20 @@
+import type { Logger } from "pino"
+import type { WorkerBackend } from "./abstractions"
+import { z } from "zod"
+import { DockerWorkerBackend, dockerWorkerBackendConfig } from "./docker"
+
+export const workerBackendConfig = z.object({
+  HIGHSTATE_WORKER_BACKEND_TYPE: z.enum(["docker"]).default("docker"),
+  ...dockerWorkerBackendConfig.shape,
+})
+
+export function createWorkerBackend(
+  config: z.infer<typeof workerBackendConfig>,
+  logger: Logger,
+): WorkerBackend {
+  switch (config.HIGHSTATE_WORKER_BACKEND_TYPE) {
+    case "docker": {
+      return DockerWorkerBackend.create(config, logger)
+    }
+  }
+}

package/src/worker/index.ts

@@ -0,0 +1,3 @@
+export * from "./abstractions"
+export * from "./factory"
+export * from "./manager"