@freestyle-sh/with-deno 0.0.1

package/README.md

@@ -0,0 +1,123 @@
+# @freestyle-sh/with-deno
+
+Deno runtime for [Freestyle](https://freestyle.sh) VMs.
+
+## Installation
+
+```bash
+npm install @freestyle-sh/with-deno freestyle-sandboxes
+```
+
+## Usage
+
+```typescript
+import { freestyle, VmSpec } from "freestyle-sandboxes";
+import { VmDeno } from "@freestyle-sh/with-deno";
+
+const spec = new VmSpec({
+  with: {
+    deno: new VmDeno(),
+  },
+});
+
+const { vm } = await freestyle.vms.create({ spec });
+
+const res = await vm.deno.runCode({
+  code: "console.log(JSON.stringify({ hello: 'world', runtime: 'deno' }));",
+});
+
+console.log(res);
+// { result: { hello: 'world', runtime: 'deno' }, stdout: '{"hello":"world","runtime":"deno"}\n', statusCode: 0 }
+```
+
+## Options
+
+```typescript
+new VmDeno({
+  version: "2.0.0",  // Optional: specific Deno version (default: latest)
+})
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `version` | `string` | `undefined` | Deno version to install. If not specified, installs the latest version. |
+
+## API
+
+### `vm.deno.runCode({ code: string })`
+
+Executes JavaScript/TypeScript code using `deno eval`.
+
+**Returns:** `Promise<RunCodeResponse>`
+
+```typescript
+type RunCodeResponse<Result> = {
+  result: Result;      // Parsed JSON from stdout (if valid JSON)
+  stdout?: string;     // Raw stdout output
+  stderr?: string;     // Raw stderr output
+  statusCode?: number; // Exit code
+};
+```
+
+### `vm.deno.install(options?)`
+
+Installs packages using Deno. Supports both npm packages and JSR (Deno's native registry).
+
+```typescript
+// Install from deno.json in current directory
+await vm.deno.install();
+
+// Install from deno.json in specific directory
+await vm.deno.install({ directory: "/app" });
+
+// Install npm packages (auto-prefixed with npm:)
+await vm.deno.install({ deps: ["lodash-es", "express"] });
+
+// Install JSR packages (use jsr: prefix)
+await vm.deno.install({ deps: ["jsr:@std/path", "jsr:@std/fs"] });
+
+// Install with specific versions
+await vm.deno.install({ deps: { "lodash-es": "^4.0.0" } });
+
+// Install as dev dependencies
+await vm.deno.install({ deps: ["typescript"], dev: true });
+
+// Install globally
+await vm.deno.install({ global: true, deps: ["jsr:@std/cli"] });
+```
+
+**Returns:** `Promise<InstallResult>`
+
+```typescript
+type InstallResult = {
+  success: boolean;
+  stdout?: string;
+  stderr?: string;
+};
+```
+
+## JSR Packages
+
+Deno has native support for [JSR](https://jsr.io) (JavaScript Registry), which hosts TypeScript-first packages including the Deno standard library.
+
+```typescript
+// Install @std/path from JSR
+await vm.deno.install({ deps: ["jsr:@std/path"] });
+
+// Use it in code
+const res = await vm.deno.runCode({
+  code: `
+    import * as path from "jsr:@std/path";
+    console.log(JSON.stringify({
+      join: path.join("foo", "bar", "baz"),
+      basename: path.basename("/home/user/file.txt"),
+    }));
+  `,
+});
+```
+
+## Documentation
+
+- [Freestyle Documentation](https://docs.freestyle.sh)
+- [Deno Documentation](https://docs.deno.com)
+- [JSR Registry](https://jsr.io)

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { VmWith, VmWithInstance, VmSpec } from 'freestyle-sandboxes';
+import { VmJavaScriptRuntimeInstance, JSONValue, RunCodeResponse, InstallOptions, InstallResult, VmJavaScriptRuntime } from '@freestyle-sh/with-type-js';
+
+type DenoOptions = {
+    version?: string;
+    workdir?: string;
+    deleteAfterSuccess?: boolean;
+};
+type DenoResolvedOptions = {
+    version?: string;
+    workdir?: string;
+    deleteAfterSuccess: boolean;
+};
+declare class VmDeno extends VmWith<VmDenoInstance> implements VmJavaScriptRuntime<VmJavaScriptRuntimeInstance> {
+    options: DenoResolvedOptions;
+    constructor(options?: DenoOptions);
+    configureSnapshotSpec(spec: VmSpec): VmSpec;
+    createInstance(): VmDenoInstance;
+    installServiceName(): string;
+}
+declare class VmDenoInstance extends VmWithInstance implements VmJavaScriptRuntimeInstance {
+    builder: VmDeno;
+    constructor(builder: VmDeno);
+    runCode<Result extends JSONValue = any>(args: string | {
+        code: string;
+        argv?: string[];
+        env?: Record<string, string>;
+        workdir?: string;
+    }): Promise<RunCodeResponse<Result>>;
+    install(options?: InstallOptions): Promise<InstallResult>;
+}
+
+export { VmDeno };

package/dist/index.js

@@ -0,0 +1,124 @@
+import { VmWith, VmSpec, VmWithInstance } from 'freestyle-sandboxes';
+
+class VmDeno extends VmWith {
+  options;
+  constructor(options) {
+    super();
+    this.options = {
+      version: options?.version,
+      workdir: options?.workdir,
+      deleteAfterSuccess: options?.deleteAfterSuccess ?? true
+    };
+  }
+  configureSnapshotSpec(spec) {
+    const versionArg = this.options.version ? ` v${this.options.version}` : "";
+    const installScript = `#!/bin/bash
+set -e
+export DENO_INSTALL="/opt/deno"
+curl -fsSL https://deno.land/install.sh | sh -s -- --yes${versionArg}
+$DENO_INSTALL/bin/deno --version
+`;
+    const denoInit = `export DENO_INSTALL="/opt/deno"
+export PATH="$DENO_INSTALL/bin:$PATH"
+`;
+    return this.composeSpecs(
+      spec,
+      new VmSpec({
+        additionalFiles: {
+          "/opt/install-deno.sh": {
+            content: installScript
+          },
+          "/etc/profile.d/deno.sh": {
+            content: denoInit
+          }
+        },
+        systemd: {
+          services: [
+            {
+              name: "install-deno",
+              mode: "oneshot",
+              deleteAfterSuccess: this.options.deleteAfterSuccess,
+              env: {
+                HOME: "/root"
+              },
+              exec: ["bash /opt/install-deno.sh"],
+              timeoutSec: 300
+            }
+          ]
+        }
+      })
+    );
+  }
+  createInstance() {
+    return new VmDenoInstance(this);
+  }
+  installServiceName() {
+    return "install-deno.service";
+  }
+}
+class VmDenoInstance extends VmWithInstance {
+  builder;
+  constructor(builder) {
+    super();
+    this.builder = builder;
+  }
+  async runCode(args) {
+    const options = typeof args === "string" ? { code: args } : args;
+    const { code, argv, env, workdir } = options;
+    const shellEscape = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+    const argvArgs = argv?.map(shellEscape).join(" ");
+    const envPrefix = env ? `${Object.entries(env).map(([key, value]) => `${key}=${shellEscape(value)}`).join(" ")} ` : "";
+    const cdPrefix = workdir ? `cd ${shellEscape(workdir)} && ` : "";
+    const command = `${cdPrefix}${envPrefix}/opt/deno/bin/deno eval "${code.replace(/"/g, '\\"')}"${argvArgs ? ` -- ${argvArgs}` : ""}`;
+    const result = await this.vm.exec({
+      command
+    });
+    let parsedResult = void 0;
+    if (result.stdout) {
+      const lines = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+      const lastLine = lines[lines.length - 1];
+      if (lastLine) {
+        try {
+          parsedResult = JSON.parse(lastLine);
+        } catch (e) {
+        }
+      }
+    }
+    return {
+      result: parsedResult,
+      stdout: result.stdout ?? void 0,
+      stderr: result.stderr ?? void 0,
+      statusCode: result.statusCode ?? -1
+    };
+  }
+  async install(options) {
+    let command;
+    const prefixDep = (dep) => {
+      if (dep.startsWith("npm:") || dep.startsWith("jsr:")) {
+        return dep;
+      }
+      return `npm:${dep}`;
+    };
+    if (options?.global) {
+      const deps = options.deps.map(prefixDep);
+      command = `/opt/deno/bin/deno install --global --allow-all ${deps.join(" ")}`;
+    } else {
+      const cdPrefix = options?.directory ? `cd ${options.directory} && ` : "";
+      if (!options?.deps) {
+        command = `${cdPrefix}/opt/deno/bin/deno install`;
+      } else {
+        const deps = Array.isArray(options.deps) ? options.deps.map(prefixDep) : Object.entries(options.deps).map(([pkg, ver]) => `${prefixDep(pkg)}@${ver}`);
+        const devFlag = options.dev ? " --dev" : "";
+        command = `${cdPrefix}/opt/deno/bin/deno add${devFlag} ${deps.join(" ")}`;
+      }
+    }
+    const result = await this.vm.exec({ command });
+    return {
+      success: result.statusCode === 0,
+      stdout: result.stdout ?? void 0,
+      stderr: result.stderr ?? void 0
+    };
+  }
+}
+
+export { VmDeno };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@freestyle-sh/with-deno",
+  "version": "0.0.1",
+  "private": false,
+  "dependencies": {
+    "freestyle-sandboxes": "^0.1.14",
+    "@freestyle-sh/with-type-js": "0.2.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "pkgroll": "^2.11.2",
+    "typescript": "^5.8.3"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "source": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pkgroll"
+  }
+}