@axiom-lattice/opensandbox-gateway 0.1.2

package/src/app.ts

@@ -0,0 +1,67 @@
+import type { FastifyInstance } from "fastify";
+import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
+import sensible from "@fastify/sensible";
+import fastify from "fastify";
+import { toErrorResponse } from "./lib/errors";
+import { registerHealthRoutes } from "./routes/health";
+import { registerImageRoutes } from "./routes/images";
+import { registerSandboxRoutes } from "./routes/sandbox";
+import { registerVolumeFsRoutes } from "./routes/volume-fs";
+import { ImageService } from "./services/ImageService";
+import { OpenSandboxRuntimeService } from "./services/OpenSandboxRuntimeService";
+import { configureSwagger } from "./swagger";
+
+export async function buildApp({
+  apiKey,
+}: {
+  apiKey?: string;
+} = {}): Promise<FastifyInstance> {
+  const runtimeService = new OpenSandboxRuntimeService();
+  const imageService = new ImageService();
+
+  const app = fastify({
+    logger: false,
+    bodyLimit: Number(process.env["BODY_LIMIT"]) || 100 * 1024 * 1024,
+  });
+
+  await app.register(cors, {
+    delegator: (request, callback) => {
+      callback(null, {
+        origin: true,
+        methods: request.headers["access-control-request-method"] ?? "*",
+        allowedHeaders: request.headers["access-control-request-headers"],
+      });
+    },
+  });
+  await app.register(sensible);
+  await app.register(multipart);
+
+  if (apiKey) {
+    app.addHook("onRequest", async (request, reply) => {
+      if (request.method === "OPTIONS" || !request.url.startsWith("/api/")) {
+        return;
+      }
+      if (request.headers.authorization !== `Bearer ${apiKey}`) {
+        await reply.code(401).send({
+          success: false,
+          error: { code: "UNAUTHORIZED", message: "Unauthorized" },
+        });
+      }
+    });
+  }
+
+  registerHealthRoutes(app);
+  registerSandboxRoutes(app, runtimeService);
+  registerImageRoutes(app, imageService);
+  registerVolumeFsRoutes(app);
+
+  app.setErrorHandler((error, _request, reply) => {
+    const { statusCode, body } = toErrorResponse(error);
+    reply.status(statusCode).send(body);
+  });
+
+  await configureSwagger(app);
+
+  return app;
+}

package/src/cli.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { startServer } from "./server";
+
+void startServer().catch((error) => {
+  console.error("Failed to start opensandbox-gateway", error);
+  process.exit(1);
+});

package/src/controllers/images.ts

@@ -0,0 +1,38 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { ZodError } from "zod";
+import { HttpError } from "../lib/errors";
+import { ok } from "../lib/http";
+import { ImageService } from "../services/ImageService";
+import { imageRefQuerySchema, pullImageSchema } from "../schemas/images";
+
+function parseOrThrow<T>(parse: () => T): T {
+  try {
+    return parse();
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new HttpError(400, "INVALID_REQUEST", error.issues[0]?.message ?? "Invalid request");
+    }
+
+    throw error;
+  }
+}
+
+export function createImageController(imageService: ImageService) {
+  return {
+    listImages: async (_request: FastifyRequest, reply: FastifyReply) => {
+      return reply.send(ok(await imageService.listImages()));
+    },
+    pullImage: async (request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply) => {
+      const body = parseOrThrow(() => pullImageSchema.parse(request.body ?? {}));
+      return reply.send(ok(await imageService.pullImage(body)));
+    },
+    getImage: async (request: FastifyRequest<{ Querystring: unknown }>, reply: FastifyReply) => {
+      const query = parseOrThrow(() => imageRefQuerySchema.parse(request.query ?? {}));
+      return reply.send(ok(await imageService.getImage(query.ref)));
+    },
+    deleteImage: async (request: FastifyRequest<{ Querystring: unknown }>, reply: FastifyReply) => {
+      const query = parseOrThrow(() => imageRefQuerySchema.parse(request.query ?? {}));
+      return reply.send(ok(await imageService.deleteImage(query.ref)));
+    },
+  };
+}

package/src/controllers/sandbox.ts

@@ -0,0 +1,176 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import {
+  downloadFileSchema,
+  ensureSandboxSchema,
+  findFilesSchema,
+  listSandboxesQuerySchema,
+  listPathSchema,
+  readFileSchema,
+  replaceInFileSchema,
+  sandboxLogsSchema,
+  sandboxNameParamsSchema,
+  searchInFileSchema,
+  shellExecSchema,
+  uploadFileSchema,
+  writeFileSchema,
+} from "../schemas/sandbox";
+import { HttpError } from "../lib/errors";
+import { ok } from "../lib/http";
+import type { RuntimeService } from "../types/runtime-service";
+
+export function createSandboxController(runtimeService: RuntimeService): {
+  ensureSandbox(
+    request: FastifyRequest<{ Params: { name: string }; Body: unknown }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  startSandbox(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  stopSandbox(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  killSandbox(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  deleteSandbox(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  listSandboxes(
+    request: FastifyRequest<{ Querystring: unknown }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  getSandbox(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  getStatus(
+    request: FastifyRequest<{ Params: { name: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  getSandboxLogs(
+    request: FastifyRequest<{ Params: { name: string }; Body: unknown }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  readFile(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  writeFile(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  listPath(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  findFiles(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  searchInFile(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  replaceInFile(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  uploadFile(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+  downloadFile(
+    request: FastifyRequest<{ Querystring: unknown }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  execCommand(request: FastifyRequest<{ Body: unknown }>, reply: FastifyReply): Promise<FastifyReply>;
+} {
+  return {
+    ensureSandbox: async (
+      request: FastifyRequest<{ Params: { name: string }; Body: unknown }>,
+      reply: FastifyReply
+    ) => {
+      const body = ensureSandboxSchema.parse(request.body ?? {});
+      const result = await runtimeService.ensureSandbox(request.params.name, body);
+      return reply.send(ok(result));
+    },
+
+    startSandbox: async (request, reply) => {
+      return reply.send(ok(await runtimeService.startSandbox(request.params.name)));
+    },
+
+    stopSandbox: async (request, reply) => {
+      return reply.send(ok(await runtimeService.stopSandbox(request.params.name)));
+    },
+
+    killSandbox: async (request, reply) => {
+      return reply.send(ok(await runtimeService.killSandbox(request.params.name)));
+    },
+
+    deleteSandbox: async (request, reply) => {
+      return reply.send(ok(await runtimeService.deleteSandbox(request.params.name)));
+    },
+
+    listSandboxes: async (request, reply) => {
+      const query = listSandboxesQuerySchema.parse(request.query ?? {});
+      return reply.send(ok(await runtimeService.listSandboxes(query)));
+    },
+
+    getSandbox: async (request, reply) => {
+      const params = sandboxNameParamsSchema.parse(request.params ?? {});
+      const sandbox = await runtimeService.getSandbox(params.name);
+
+      if (!sandbox) {
+        throw new HttpError(404, "SANDBOX_NOT_FOUND", `Sandbox '${params.name}' not found`);
+      }
+
+      return reply.send(ok(sandbox));
+    },
+
+    getStatus: async (request, reply) => {
+      return reply.send(ok(await runtimeService.getStatus(request.params.name)));
+    },
+
+    getSandboxLogs: async (request, reply) => {
+      const body = sandboxLogsSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.getSandboxLogs(request.params.name, body)));
+    },
+
+    readFile: async (request, reply) => {
+      const body = readFileSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.readFile(body.sandboxName, body.path)));
+    },
+
+    writeFile: async (request, reply) => {
+      const body = writeFileSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.writeFile(body.sandboxName, body.path, body.content)));
+    },
+
+    listPath: async (request, reply) => {
+      const body = listPathSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.listPath(body.sandboxName, body.path, body.recursive)));
+    },
+
+    findFiles: async (request, reply) => {
+      const body = findFilesSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.findFiles(body.sandboxName, body.path, body.pattern)));
+    },
+
+    searchInFile: async (request, reply) => {
+      const body = searchInFileSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.searchInFile(body.sandboxName, body.path, body.query)));
+    },
+
+    replaceInFile: async (request, reply) => {
+      const body = replaceInFileSchema.parse(request.body ?? {});
+      return reply.send(
+        ok(
+          await runtimeService.replaceInFile(body.sandboxName, {
+            path: body.path,
+            search: body.search,
+            replace: body.replace,
+          })
+        )
+      );
+    },
+
+    uploadFile: async (request, reply) => {
+      const body = uploadFileSchema.parse(request.body ?? {});
+      const contentBase64 = "contentBase64" in body ? body.contentBase64 : Buffer.from(body.content).toString("base64");
+      return reply.send(ok(await runtimeService.uploadFile(body.sandboxName, body.path, contentBase64)));
+    },
+
+    downloadFile: async (request, reply) => {
+      const query = downloadFileSchema.parse(request.query ?? {});
+      return reply.send(ok(await runtimeService.downloadFile(query.sandboxName, query.path)));
+    },
+
+    execCommand: async (request, reply) => {
+      const body = shellExecSchema.parse(request.body ?? {});
+      return reply.send(ok(await runtimeService.execCommand(body)));
+    },
+  };
+}

package/src/controllers/volume-fs.ts

@@ -0,0 +1,163 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import z from "zod";
+import { HttpError } from "../lib/errors";
+import { ok } from "../lib/http";
+import {
+  volumeFsReadSchema,
+  volumeFsWriteSchema,
+  volumeFsListSchema,
+  volumeFsUploadSchema,
+  volumeFsDownloadSchema,
+} from "../schemas/volume-fs";
+
+interface VolumeFsParams {
+  name: string;
+}
+
+function getVolumeBasePath(): string {
+  return process.env.VOLUME_BASE_PATH ?? path.join(os.homedir(), ".opensandbox", "volumes");
+}
+
+function resolveVolumeHostPath(name: string): string {
+  return path.join(getVolumeBasePath(), name);
+}
+
+function resolveGuestPath(hostRoot: string, guestPath: string): string {
+  const normalized = guestPath === "~" ? "" : guestPath.replace(/^~\//, "");
+  const resolved = path.join(
+    hostRoot,
+    path.normalize(normalized).replace(/^(\.\.(\/|\\|$))+/, "")
+  );
+  if (!resolved.startsWith(hostRoot + path.sep) && resolved !== hostRoot) {
+    throw new HttpError(403, "PATH_TRAVERSAL", "Path traversal detected");
+  }
+  return resolved;
+}
+
+export function createVolumeFsController(): {
+  readFile(
+    request: FastifyRequest<{ Params: VolumeFsParams; Body: { path: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  writeFile(
+    request: FastifyRequest<{ Params: VolumeFsParams; Body: { path: string; content: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  listPath(
+    request: FastifyRequest<{ Params: VolumeFsParams; Body: { path: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  downloadFile(
+    request: FastifyRequest<{ Params: VolumeFsParams; Querystring: { path: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+  uploadFile(
+    request: FastifyRequest<{ Params: VolumeFsParams; Body: { path: string; contentBase64: string } }>,
+    reply: FastifyReply
+  ): Promise<FastifyReply>;
+} {
+  return {
+    readFile: async (request, reply) => {
+      const { name } = request.params;
+
+      try {
+        const { path: guestPath } = volumeFsReadSchema.parse(request.body ?? {});
+        const hostRoot = resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        const content = await fs.readFile(fullPath, "utf-8");
+        return reply.send(ok({ path: guestPath, content }));
+      } catch (err: unknown) {
+        if (err instanceof z.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(404, "VOLUME_READ_ERROR", `Failed to read from volume '${name}': ${String(err)}`);
+      }
+    },
+
+    writeFile: async (request, reply) => {
+      const { name } = request.params;
+
+      try {
+        const { path: guestPath, content } = volumeFsWriteSchema.parse(request.body ?? {});
+        const hostRoot = resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, content, "utf-8");
+        return reply.send(ok({ path: guestPath }));
+      } catch (err: unknown) {
+        if (err instanceof z.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(500, "VOLUME_WRITE_ERROR", `Failed to write to volume '${name}': ${String(err)}`);
+      }
+    },
+
+    listPath: async (request, reply) => {
+      const { name } = request.params;
+
+      try {
+        const { path: guestPath } = volumeFsListSchema.parse(request.body ?? {});
+        const hostRoot = resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        const dirents = await fs.readdir(fullPath, { withFileTypes: true });
+        const entries = dirents.map((d) => ({
+          path: guestPath ? `${guestPath}/${d.name}` : d.name,
+          kind: d.isDirectory() ? "directory" : d.isSymbolicLink() ? "symlink" : "file",
+          size: 0,
+          mode: 0,
+        }));
+        return reply.send(ok({ entries }));
+      } catch (err: unknown) {
+        if (err instanceof z.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(404, "VOLUME_LIST_ERROR", `Failed to list volume '${name}': ${String(err)}`);
+      }
+    },
+
+    downloadFile: async (request, reply) => {
+      const { name } = request.params;
+
+      try {
+        const { path: guestPath } = volumeFsDownloadSchema.parse(request.query ?? {});
+        const hostRoot = resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        const buf = await fs.readFile(fullPath);
+        const contentBase64 = buf.toString("base64");
+        return reply.send(ok({ path: guestPath, contentBase64 }));
+      } catch (err: unknown) {
+        if (err instanceof z.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(404, "VOLUME_DOWNLOAD_ERROR", `Failed to download from volume '${name}': ${String(err)}`);
+      }
+    },
+
+    uploadFile: async (request, reply) => {
+      const { name } = request.params;
+
+      try {
+        const { path: guestPath, contentBase64 } = volumeFsUploadSchema.parse(request.body ?? {});
+        const hostRoot = resolveVolumeHostPath(name);
+        const fullPath = resolveGuestPath(hostRoot, guestPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const data = Buffer.from(contentBase64, "base64");
+        await fs.writeFile(fullPath, data);
+        return reply.send(ok({ path: guestPath }));
+      } catch (err: unknown) {
+        if (err instanceof z.ZodError) {
+          throw new HttpError(400, "VALIDATION_ERROR", err.message);
+        }
+        if (err instanceof HttpError) throw err;
+        throw new HttpError(500, "VOLUME_UPLOAD_ERROR", `Failed to upload to volume '${name}': ${String(err)}`);
+      }
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { buildApp } from "./app";
+export { startServer } from "./server";
+export { OpenSandboxRuntimeService } from "./services/OpenSandboxRuntimeService";

package/src/lib/errors.ts

@@ -0,0 +1,44 @@
+export class HttpError extends Error {
+  constructor(
+    public statusCode: number,
+    public code: string,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export function toErrorResponse(error: unknown): {
+  statusCode: number;
+  body: {
+    success: false;
+    error: {
+      code: string;
+      message: string;
+    };
+  };
+} {
+  if (error instanceof HttpError) {
+    return {
+      statusCode: error.statusCode,
+      body: {
+        success: false,
+        error: {
+          code: error.code,
+          message: error.message,
+        },
+      },
+    };
+  }
+
+  return {
+    statusCode: 500,
+    body: {
+      success: false,
+      error: {
+        code: "INTERNAL_ERROR",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    },
+  };
+}

package/src/lib/http.ts

@@ -0,0 +1,11 @@
+export type SuccessResponse<T> = {
+  success: true;
+  data: T;
+};
+
+export function ok<T>(data: T): SuccessResponse<T> {
+  return {
+    success: true,
+    data,
+  };
+}

package/src/lib/server-cli.ts

@@ -0,0 +1,65 @@
+export interface ParsedServerArgs {
+  host?: string;
+  port?: number;
+}
+
+export interface ResolvedServerConfig {
+  host: string;
+  port: number;
+  apiKey?: string;
+}
+
+function parsePort(raw: string, source: string): number {
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0 || value > 65535) {
+    throw new Error(`Invalid value for ${source}: ${raw}`);
+  }
+  return value;
+}
+
+function isMissingOptionValue(raw: string | undefined): raw is undefined {
+  return !raw || raw.startsWith("--");
+}
+
+export function parseServerArgs(argv: string[]): ParsedServerArgs {
+  const parsed: ParsedServerArgs = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === "--port") {
+      const raw = argv[index + 1];
+      if (isMissingOptionValue(raw)) {
+        throw new Error("Missing value for --port");
+      }
+      parsed.port = parsePort(raw, "--port");
+      index += 1;
+      continue;
+    }
+
+    if (token === "--host") {
+      const raw = argv[index + 1];
+      if (isMissingOptionValue(raw)) {
+        throw new Error("Missing value for --host");
+      }
+      parsed.host = raw;
+      index += 1;
+    }
+  }
+
+  return parsed;
+}
+
+export function resolveServerConfig({
+  args,
+  env,
+}: {
+  args: ParsedServerArgs;
+  env: NodeJS.ProcessEnv;
+}): ResolvedServerConfig {
+  return {
+    host: args.host ?? env.HOST ?? "0.0.0.0",
+    port: args.port ?? (env.PORT ? parsePort(env.PORT, "PORT") : 4002),
+    apiKey: env.GATEWAY_API_KEY ?? env.MICROSANDBOX_API_KEY,
+  };
+}

package/src/routes/health.ts

@@ -0,0 +1,6 @@
+import type { FastifyInstance } from "fastify";
+import { ok } from "../lib/http";
+
+export function registerHealthRoutes(app: FastifyInstance): void {
+  app.get("/health", async () => ok({ status: "ok" }));
+}

package/src/routes/images.ts

@@ -0,0 +1,12 @@
+import type { FastifyInstance } from "fastify";
+import { createImageController } from "../controllers/images";
+import { ImageService } from "../services/ImageService";
+
+export function registerImageRoutes(app: FastifyInstance, imageService: ImageService): void {
+  const controller = createImageController(imageService);
+
+  app.get("/api/images", controller.listImages);
+  app.post("/api/images/pull", controller.pullImage);
+  app.get("/api/images/detail", controller.getImage);
+  app.delete("/api/images/detail", controller.deleteImage);
+}

package/src/routes/sandbox.ts

@@ -0,0 +1,31 @@
+import type { FastifyInstance } from "fastify";
+import { createSandboxController } from "../controllers/sandbox";
+import type { RuntimeService } from "../types/runtime-service";
+
+export function registerSandboxRoutes(
+  app: FastifyInstance,
+  runtimeService: RuntimeService
+): void {
+  const controller = createSandboxController(runtimeService);
+
+  app.get("/api/sandboxes", controller.listSandboxes);
+  app.get("/api/sandboxes/:name", controller.getSandbox);
+  app.put("/api/sandboxes/:name", controller.ensureSandbox);
+  app.post("/api/sandboxes/:name/start", controller.startSandbox);
+  app.post("/api/sandboxes/:name/stop", controller.stopSandbox);
+  app.post("/api/sandboxes/:name/kill", controller.killSandbox);
+  app.delete("/api/sandboxes/:name", controller.deleteSandbox);
+  app.get("/api/sandboxes/:name/status", controller.getStatus);
+  app.post("/api/sandboxes/:name/logs", controller.getSandboxLogs);
+
+  app.post("/api/files/read", controller.readFile);
+  app.post("/api/files/write", controller.writeFile);
+  app.post("/api/files/list", controller.listPath);
+  app.post("/api/files/find", controller.findFiles);
+  app.post("/api/files/search", controller.searchInFile);
+  app.post("/api/files/replace", controller.replaceInFile);
+  app.post("/api/files/upload", controller.uploadFile);
+  app.get("/api/files/download", controller.downloadFile);
+
+  app.post("/api/shell/exec", controller.execCommand);
+}

package/src/routes/volume-fs.ts

@@ -0,0 +1,12 @@
+import type { FastifyInstance } from "fastify";
+import { createVolumeFsController } from "../controllers/volume-fs";
+
+export function registerVolumeFsRoutes(app: FastifyInstance): void {
+  const controller = createVolumeFsController();
+
+  app.post("/api/volumes/:name/fs/read", controller.readFile);
+  app.post("/api/volumes/:name/fs/write", controller.writeFile);
+  app.post("/api/volumes/:name/fs/list", controller.listPath);
+  app.get("/api/volumes/:name/fs/download", controller.downloadFile);
+  app.post("/api/volumes/:name/fs/upload", controller.uploadFile);
+}

package/src/schemas/images.ts

@@ -0,0 +1,12 @@
+import z from "zod";
+
+export const imageRefQuerySchema = z.object({
+  ref: z.string().min(1),
+});
+
+export const pullImageSchema = z.object({
+  ref: z.string().min(1),
+});
+
+export type ImageRefQuery = z.infer<typeof imageRefQuerySchema>;
+export type PullImageInput = z.infer<typeof pullImageSchema>;