@freestyle-sh/with-deno 0.0.1 → 0.0.3

package/README.md

@@ -14,11 +14,8 @@ npm install @freestyle-sh/with-deno freestyle-sandboxes
 import { freestyle, VmSpec } from "freestyle-sandboxes";
 import { VmDeno } from "@freestyle-sh/with-deno";
 
-const spec = new VmSpec({
-  with: {
-    deno: new VmDeno(),
-  },
-});
+const deno = new VmDeno();
+const spec = new VmSpec().with("deno", deno);
 
 const { vm } = await freestyle.vms.create({ spec });
 
@@ -101,6 +98,10 @@ type InstallResult = {
 Deno has native support for [JSR](https://jsr.io) (JavaScript Registry), which hosts TypeScript-first packages including the Deno standard library.
 
 ```typescript
+const deno = new VmDeno();
+const spec = new VmSpec().with("deno", deno);
+const { vm } = await freestyle.vms.create({ spec });
+
 // Install @std/path from JSR
 await vm.deno.install({ deps: ["jsr:@std/path"] });
 
@@ -116,6 +117,81 @@ const res = await vm.deno.runCode({
 });
 ```
 
+## Workspaces and Tasks
+
+Use the Deno builder to attach a workspace and run a Deno task as a managed systemd service.
+
+```typescript
+import { Freestyle, VmSpec } from "freestyle-sandboxes";
+import { VmDeno } from "@freestyle-sh/with-deno";
+
+const freestyle = new Freestyle();
+
+const deno = new VmDeno();
+const workspace = deno.workspace({ path: "/root/app", install: true });
+const appTask = workspace.task("start", {
+  env: {
+    HOST: "0.0.0.0",
+  },
+});
+
+const spec = new VmSpec()
+  .with("deno", deno)
+  .repo("https://github.com/deco-sites/storefront", "/root/app")
+  .with("workspace", workspace)
+  .with("app", appTask)
+  .snapshot()
+  .waitFor("curl http://localhost:8000")
+  .snapshot();
+
+const { repoId } = await freestyle.git.repos.create({
+  source: {
+    url: "https://github.com/deco-sites/storefront",
+  },
+});
+
+const domain = `${crypto.randomUUID()}.style.dev`;
+
+const { vm } = await freestyle.vms.create({
+  spec,
+  domains: [{ domain, vmPort: 8000 }],
+  git: {
+    repos: [{ repo: repoId, path: "/root/app" }],
+  },
+});
+
+// Task instance comes from .with("app", appTask)
+const recentLogs = await vm.app.logs();
+console.log(recentLogs);
+```
+
+### Workspace API
+
+```typescript
+const workspace = deno.workspace({
+  path: "/root/app",
+  install: true,
+});
+```
+
+- `path`: Working directory for `deno install` and task execution.
+- `install`: When true, runs `deno install` in the workspace during VM startup.
+
+### Task API
+
+```typescript
+const task = workspace.task("start", {
+  env: { HOST: "0.0.0.0" },
+  serviceName: "my-deno-app",
+});
+```
+
+- `name`: Task name from `deno.json`.
+- `env`: Optional environment variables for the task service.
+- `serviceName`: Optional explicit systemd service name.
+
+When added to the spec with `.with("app", task)`, you can access task logs with `vm.app.logs()`.
+
 ## Documentation
 
 - [Freestyle Documentation](https://docs.freestyle.sh)

package/dist/index.d.ts

@@ -1,23 +1,66 @@
-import { VmWith, VmWithInstance, VmSpec } from 'freestyle-sandboxes';
+import { VmWith, VmWithInstance, VmSpec, VmBaseImage } 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;
+    workspaces: DenoWorkspace[];
     constructor(options?: DenoOptions);
-    configureSnapshotSpec(spec: VmSpec): VmSpec;
+    configureBaseImage(image: VmBaseImage): VmBaseImage | Promise<VmBaseImage>;
+    configureSpec(spec: VmSpec): VmSpec;
+    workspace(options: {
+        path: string;
+        install?: boolean;
+    }): DenoWorkspace;
     createInstance(): VmDenoInstance;
     installServiceName(): string;
 }
+declare class DenoWorkspace extends VmWith<DenoWorkspaceInstance> {
+    options: {
+        path: string;
+        install?: boolean;
+    };
+    env?: Record<string, string>;
+    constructor(options: {
+        path: string;
+        install?: boolean;
+    }, env?: Record<string, string>);
+    task(name: string, options?: {
+        env?: Record<string, string>;
+        serviceName?: string;
+    }): DenoWorkspaceTask;
+    getInstallServiceName(): string;
+    configureSpec(spec: VmSpec): VmSpec;
+    createInstance(): DenoWorkspaceInstance;
+}
+declare class DenoWorkspaceInstance extends VmWithInstance {
+}
+declare class DenoWorkspaceTask extends VmWith<DenoWorkspaceTaskInstance> {
+    name: string;
+    workspace: DenoWorkspace;
+    env?: Record<string, string>;
+    serviceName?: string;
+    constructor(name: string, workspace: DenoWorkspace, env?: Record<string, string>, serviceName?: string);
+    getServiceName(): string;
+    configureSpec(spec: VmSpec): VmSpec;
+    createInstance(): DenoWorkspaceTaskInstance;
+}
+declare class DenoWorkspaceTaskInstance extends VmWithInstance {
+    name: string;
+    workspace: DenoWorkspace;
+    env?: Record<string, string>;
+    serviceName?: string;
+    constructor(name: string, workspace: DenoWorkspace, env?: Record<string, string>, serviceName?: string);
+    getServiceName(): string;
+    logs(): Promise<string[] | undefined>;
+}
 declare class VmDenoInstance extends VmWithInstance implements VmJavaScriptRuntimeInstance {
     builder: VmDeno;
     constructor(builder: VmDeno);
@@ -30,4 +73,4 @@ declare class VmDenoInstance extends VmWithInstance implements VmJavaScriptRunti
     install(options?: InstallOptions): Promise<InstallResult>;
 }
 
-export { VmDeno };
+export { DenoWorkspace, DenoWorkspaceInstance, DenoWorkspaceTask, DenoWorkspaceTaskInstance, VmDeno };

package/dist/index.js

@@ -1,53 +1,40 @@
-import { VmWith, VmSpec, VmWithInstance } from 'freestyle-sandboxes';
+import { VmWith, VmWithInstance } from 'freestyle-sandboxes';
 
 class VmDeno extends VmWith {
   options;
+  workspaces = [];
   constructor(options) {
     super();
     this.options = {
       version: options?.version,
-      workdir: options?.workdir,
-      deleteAfterSuccess: options?.deleteAfterSuccess ?? true
+      workdir: options?.workdir
     };
   }
-  configureSnapshotSpec(spec) {
+  configureBaseImage(image) {
     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
-            }
-          ]
-        }
-      })
-    );
+    return image.runCommands(`
+apt-get update
+apt-get install -y --no-install-recommends ca-certificates curl unzip
+rm -rf /var/lib/apt/lists/*
+curl -fsSL https://deno.land/install.sh | DENO_INSTALL="/opt/deno" sh -s -- --yes${versionArg}
+/opt/deno/bin/deno --version`);
+  }
+  configureSpec(spec) {
+    spec.systemdService({
+      name: "install-deno",
+      mode: "oneshot",
+      env: {
+        HOME: "/root"
+      },
+      exec: ["/opt/deno/bin/deno --version"],
+      timeoutSec: 30
+    });
+    return spec;
+  }
+  workspace(options) {
+    const workspace = new DenoWorkspace(options);
+    this.workspaces.push(workspace);
+    return workspace;
   }
   createInstance() {
     return new VmDenoInstance(this);
@@ -56,6 +43,112 @@ export PATH="$DENO_INSTALL/bin:$PATH"
     return "install-deno.service";
   }
 }
+class DenoWorkspace extends VmWith {
+  options;
+  env;
+  constructor(options, env) {
+    super();
+    this.options = options;
+    this.env = env;
+  }
+  task(name, options) {
+    return new DenoWorkspaceTask(
+      name,
+      this,
+      {
+        ...this.env,
+        ...options?.env
+      },
+      options?.serviceName
+    );
+  }
+  getInstallServiceName() {
+    return `deno-install-${this.options.path.replace(/\//g, "-")}`;
+  }
+  configureSpec(spec) {
+    if (this.options.install) {
+      spec.systemdService({
+        name: this.getInstallServiceName(),
+        mode: "oneshot",
+        bash: "/opt/deno/bin/deno install",
+        workdir: this.options.path,
+        env: {
+          HOME: "/root",
+          DENO_DIR: "/root/.cache/deno",
+          ...this.env
+        },
+        user: "root"
+      });
+    }
+    return spec;
+  }
+  createInstance() {
+    return new DenoWorkspaceInstance();
+  }
+}
+class DenoWorkspaceInstance extends VmWithInstance {
+}
+class DenoWorkspaceTask extends VmWith {
+  name;
+  workspace;
+  env;
+  serviceName;
+  constructor(name, workspace, env, serviceName) {
+    super();
+    this.name = name;
+    this.workspace = workspace;
+    this.env = env;
+    this.serviceName = serviceName;
+  }
+  getServiceName() {
+    return this.serviceName ?? `deno-workspace-${this.workspace.options.path.replace(/\//g, "-")}-task-${this.name}`;
+  }
+  configureSpec(spec) {
+    spec.systemdService({
+      name: this.getServiceName(),
+      bash: `/opt/deno/bin/deno task ${this.name}`,
+      workdir: this.workspace.options.path,
+      after: [this.workspace.getInstallServiceName()],
+      requires: [this.workspace.getInstallServiceName()],
+      env: {
+        HOME: "/root",
+        DENO_DIR: "/root/.cache/deno",
+        ...this.env
+      },
+      user: "root"
+    });
+    return spec;
+  }
+  createInstance() {
+    return new DenoWorkspaceTaskInstance(
+      this.name,
+      this.workspace,
+      this.env,
+      this.serviceName
+    );
+  }
+}
+class DenoWorkspaceTaskInstance extends VmWithInstance {
+  name;
+  workspace;
+  env;
+  serviceName;
+  constructor(name, workspace, env, serviceName) {
+    super();
+    this.name = name;
+    this.workspace = workspace;
+    this.env = env;
+    this.serviceName = serviceName;
+  }
+  getServiceName() {
+    return this.serviceName ?? `deno-workspace-${this.workspace.options.path.replace(/\//g, "-")}-task-${this.name}`;
+  }
+  logs() {
+    return this.vm.exec({
+      command: `journalctl -u ${this.getServiceName()} --no-pager -n 30`
+    }).then((result) => result.stdout?.trim().split("\n"));
+  }
+}
 class VmDenoInstance extends VmWithInstance {
   builder;
   constructor(builder) {
@@ -107,7 +200,9 @@ class VmDenoInstance extends VmWithInstance {
       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 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(" ")}`;
       }
@@ -121,4 +216,4 @@ class VmDenoInstance extends VmWithInstance {
   }
 }
 
-export { VmDeno };
+export { DenoWorkspace, DenoWorkspaceInstance, DenoWorkspaceTask, DenoWorkspaceTaskInstance, VmDeno };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@freestyle-sh/with-deno",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
   "dependencies": {
-    "freestyle-sandboxes": "^0.1.14",
-    "@freestyle-sh/with-type-js": "0.2.8"
+    "freestyle-sandboxes": "^0.1.43",
+    "@freestyle-sh/with-type-js": "0.2.9"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",