Flue

{
  "name": "flue-superserve",
  "private": true,
  "type": "module",
  "dependencies": {
    "@flue/runtime": "^2.3.0",
    "@superserve/sdk": "^0.11.6"
  },
  "devDependencies": {
    "@flue/cli": "^2.3.0"
  },
  "overrides": {
    "@earendil-works/pi-ai": "1.4.0",
    "@earendil-works/pi-agent-core": "1.4.0"
  }
}

SUPERSERVE_API_KEY=ss_live_...
ANTHROPIC_API_KEY=sk-ant-...

import { sandboxFromDriver } from "@flue/runtime"
import type {
  FileStat,
  Sandbox as FlueSandbox,
  SandboxDriver,
  ShellResult,
} from "@flue/runtime"
import type { Sandbox } from "@superserve/sdk"

export interface SuperserveAdapterOptions {
  /** Working directory for the agent. Defaults to `/home/user`. */
  cwd?: string
  /** Timeout for commands that do not set one. Defaults to 10 minutes. */
  defaultTimeoutMs?: number
}

// Quote a value for /bin/sh.
const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`

class SuperserveDriver implements SandboxDriver {
  private readonly sandbox: Sandbox
  private readonly defaultTimeoutMs: number

  constructor(sandbox: Sandbox, defaultTimeoutMs: number) {
    this.sandbox = sandbox
    this.defaultTimeoutMs = defaultTimeoutMs
  }

  async exec(
    command: string,
    options?: { cwd?: string; env?: Record<string, string>; timeoutMs?: number },
  ): Promise<ShellResult> {
    // A non-zero exit resolves with its exit code. When the timeout expires,
    // the sandbox stops the command and returns exit code 124. The abort
    // signal is not passed on: aborting the request does not stop the command.
    const { stdout, stderr, exitCode } = await this.sandbox.commands.run(
      command,
      {
        cwd: options?.cwd,
        env: options?.env,
        timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
      },
    )
    return { stdout, stderr, exitCode }
  }

  readFile(path: string): Promise<string> {
    return this.sandbox.files.readText(path)
  }

  readFileBuffer(path: string): Promise<Uint8Array> {
    return this.sandbox.files.read(path)
  }

  writeFile(path: string, content: string | Uint8Array): Promise<void> {
    return this.sandbox.files.write(path, content)
  }

  async stat(path: string): Promise<FileStat> {
    const p = quote(path)
    const out = await this.sh(
      `stat -L -c '%F|%s|%Y' -- ${p} && { [ -L ${p} ] && echo link || echo file; }`,
    )
    const [info = "", kind] = out.trim().split("\n")
    const [type = "", size, mtime] = info.split("|")
    return {
      isFile: type.startsWith("regular"),
      isDirectory: type === "directory",
      isSymbolicLink: kind === "link",
      size: Number(size),
      mtime: new Date(Number(mtime) * 1000),
    }
  }

  async readdir(path: string): Promise<string[]> {
    const out = await this.sh(
      `cd -- ${quote(path)} && find . -mindepth 1 -maxdepth 1 -printf '%f\\0'`,
    )
    return out.split("\0").filter(Boolean)
  }

  async exists(path: string): Promise<boolean> {
    const p = quote(path)
    return (await this.exec(`[ -e ${p} ] || [ -L ${p} ]`)).exitCode === 0
  }

  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
    await this.sh(`mkdir ${options?.recursive ? "-p " : ""}-- ${quote(path)}`)
  }

  async rm(
    path: string,
    options?: { recursive?: boolean; force?: boolean },
  ): Promise<void> {
    const flags = `${options?.recursive ? "r" : ""}${options?.force ? "f" : ""}`
    await this.sh(`rm ${flags ? `-${flags} ` : ""}-- ${quote(path)}`)
  }

  // Run a helper command and throw its stderr when it fails.
  private async sh(command: string): Promise<string> {
    const { stdout, stderr, exitCode } = await this.exec(command)
    if (exitCode !== 0) {
      throw new Error(stderr.trim() || `${command} exited with ${exitCode}`)
    }
    return stdout
  }
}

/** Wrap a Superserve sandbox as a Flue sandbox. */
export function superserve(
  sandbox: Sandbox,
  options: SuperserveAdapterOptions = {},
): FlueSandbox {
  const driver = new SuperserveDriver(
    sandbox,
    options.defaultTimeoutMs ?? 10 * 60_000,
  )
  return sandboxFromDriver(driver, options.cwd ?? "/home/user")
}

import { Template } from "@superserve/sdk"

const template = await Template.create({
  name: "flue-coder",
  from: "node:22",
  steps: [{ run: "apt-get update && apt-get install -y ripgrep" }],
})
await template.waitUntilReady()
console.log(`Template ${template.name} is ready`)

import { Sandbox } from "@superserve/sdk"

const [agentId] = process.argv.slice(2)
if (!agentId) throw new Error("Usage: delete-sandbox.ts <agent-id>")

for (const { id } of await Sandbox.list({
  metadata: { flueAgent: "coder", flueAgentId: agentId },
})) {
  await Sandbox.killById(id)
  console.log(`Deleted sandbox ${id}`)
}