@axiom-lattice/opensandbox-gateway 0.1.2

package/src/schemas/sandbox.ts

@@ -0,0 +1,98 @@
+import z from "zod";
+
+const bindMountSchema = z.object({
+  type: z.literal("bind"),
+  source: z.string().min(1),
+  readonly: z.boolean().optional(),
+});
+
+const namedMountSchema = z.object({
+  type: z.literal("named"),
+  name: z.string().min(1),
+  readonly: z.boolean().optional(),
+});
+
+const tmpfsMountSchema = z.object({
+  type: z.literal("tmpfs"),
+  sizeMib: z.number().int().positive().optional(),
+});
+
+export const volumeSchema = z.union([
+  bindMountSchema,
+  namedMountSchema,
+  tmpfsMountSchema,
+]);
+
+export const ensureSandboxSchema = z.object({
+  image: z.string().optional(),
+  cpus: z.number().int().positive().optional(),
+  memoryMib: z.number().int().positive().optional(),
+  env: z.record(z.string()).optional(),
+  volumes: z.record(volumeSchema).optional(),
+});
+
+export const sandboxNameParamsSchema = z.object({
+  name: z.string().min(1),
+});
+
+export const listSandboxesQuerySchema = z.object({
+  status: z.enum(["running", "stopped", "crashed", "unknown"]).optional(),
+  image: z.string().min(1).optional(),
+  search: z.string().min(1).optional(),
+});
+
+const sandboxAndPathSchema = z.object({
+  sandboxName: z.string().min(1),
+  path: z.string().min(1),
+});
+
+export const readFileSchema = sandboxAndPathSchema;
+
+export const writeFileSchema = sandboxAndPathSchema.extend({
+  content: z.string(),
+});
+
+export const listPathSchema = sandboxAndPathSchema.extend({
+  recursive: z.boolean().optional(),
+});
+
+export const findFilesSchema = sandboxAndPathSchema.extend({
+  pattern: z.string().min(1),
+});
+
+export const searchInFileSchema = sandboxAndPathSchema.extend({
+  query: z.string().min(1),
+});
+
+export const replaceInFileSchema = sandboxAndPathSchema.extend({
+  search: z.string(),
+  replace: z.string(),
+});
+
+export const uploadFileSchema = sandboxAndPathSchema.and(
+  z.union([
+    z.object({ contentBase64: z.string() }),
+    z.object({ content: z.string().transform((content) => Buffer.from(content).toString("base64")) }),
+  ])
+);
+
+export const downloadFileSchema = sandboxAndPathSchema;
+
+export const shellExecSchema = z.object({
+  sandboxName: z.string().min(1),
+  command: z.string().min(1),
+  exec_dir: z.string().optional(),
+  timeout: z.number().int().positive().optional(),
+});
+
+export const sandboxLogsSchema = z.object({
+  tail: z.number().int().positive().optional(),
+  since: z.string().optional(),
+  until: z.string().optional(),
+  sources: z.array(z.string()).optional(),
+});
+
+export type EnsureSandboxInput = z.infer<typeof ensureSandboxSchema>;
+export type ListSandboxesQuery = z.infer<typeof listSandboxesQuerySchema>;
+export type ShellExecInput = z.infer<typeof shellExecSchema>;
+export type SandboxLogsInput = z.infer<typeof sandboxLogsSchema>;

package/src/schemas/volume-fs.ts

@@ -0,0 +1,23 @@
+import z from "zod";
+
+export const volumeFsReadSchema = z.object({
+  path: z.string(),
+});
+
+export const volumeFsWriteSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+});
+
+export const volumeFsListSchema = z.object({
+  path: z.string(),
+});
+
+export const volumeFsUploadSchema = z.object({
+  path: z.string(),
+  contentBase64: z.string().min(1),
+});
+
+export const volumeFsDownloadSchema = z.object({
+  path: z.string(),
+});

package/src/server.ts

@@ -0,0 +1,50 @@
+import type { FastifyInstance } from "fastify";
+import { buildApp } from "./app";
+import { parseServerArgs, resolveServerConfig } from "./lib/server-cli";
+
+export async function startServer({
+  argv = process.argv.slice(2),
+  env = process.env,
+  app,
+}: {
+  argv?: string[];
+  env?: NodeJS.ProcessEnv;
+  app?: Pick<FastifyInstance, "listen" | "close">;
+} = {}): Promise<Pick<FastifyInstance, "listen" | "close">> {
+  const config = resolveServerConfig({ args: parseServerArgs(argv), env });
+  const resolvedApp = app ?? (await buildApp({ apiKey: config.apiKey }));
+
+  const removeSignalHandlers = (): void => {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+  };
+
+  const close = async (): Promise<undefined> => {
+    removeSignalHandlers();
+    return resolvedApp.close();
+  };
+
+  const onSigInt = () => { void shutdown(0); };
+  const onSigTerm = () => { void shutdown(0); };
+
+  const shutdown = async (code: number): Promise<void> => {
+    try {
+      await close();
+      process.exit(code);
+    } catch (error) {
+      console.error("Failed to shutdown opensandbox-gateway cleanly", error);
+      process.exit(1);
+    }
+  };
+
+  process.once("SIGINT", onSigInt);
+  process.once("SIGTERM", onSigTerm);
+
+  try {
+    await resolvedApp.listen({ port: config.port, host: config.host });
+    return { listen: resolvedApp.listen.bind(resolvedApp), close: close as FastifyInstance["close"] };
+  } catch (error) {
+    removeSignalHandlers();
+    throw error;
+  }
+}

package/src/services/ImageService.ts

@@ -0,0 +1,32 @@
+import type { PullImageInput } from "../schemas/images";
+
+export type ImageRecord = {
+  ref: string;
+  sourceType: string;
+  cached: boolean;
+  size?: number;
+  createdAt?: string;
+  lastUsedAt?: string;
+};
+
+export class ImageService {
+  async listImages(): Promise<{ items: ImageRecord[]; total: number }> {
+    return { items: [], total: 0 };
+  }
+
+  async pullImage(_input: PullImageInput): Promise<ImageRecord> {
+    throw new Error("Image pull not supported in OpenSandbox gateway");
+  }
+
+  async getImage(ref: string): Promise<ImageRecord> {
+    return {
+      ref,
+      sourceType: "oci",
+      cached: false,
+    };
+  }
+
+  async deleteImage(ref: string): Promise<{ ref: string }> {
+    return { ref };
+  }
+}