@freestyle-sh/with-bun 0.2.9 → 0.2.11

package/README.md

@@ -91,6 +91,83 @@ type InstallResult = {
 };
 ```
 
+## Workspaces and Tasks
+
+Use the Bun builder to attach a workspace and run a package script as a managed systemd service.
+
+```typescript
+import { freestyle, VmSpec } from "freestyle-sandboxes";
+import { VmBun } from "@freestyle-sh/with-bun";
+
+const SOURCE_REPO = "https://github.com/freestyle-sh/freestyle-next";
+
+const bun = new VmBun();
+const workspace = bun.workspace({ path: "/root/app", install: true });
+const appTask = workspace.task("dev", {
+  env: {
+    HOST: "0.0.0.0",
+    PORT: "3000",
+  },
+});
+
+const spec = new VmSpec()
+  .with("bun", bun)
+  .repo(SOURCE_REPO, "/root/app")
+  .with("workspace", workspace)
+  .with("app", appTask)
+  .snapshot()
+  .waitFor("curl http://localhost:3000")
+  .snapshot();
+
+const { repoId } = await freestyle.git.repos.create({
+  source: {
+    url: SOURCE_REPO,
+  },
+});
+
+const domain = `${repoId}.style.dev`;
+
+const { vm } = await freestyle.vms.create({
+  spec,
+  domains: [{ domain, vmPort: 3000 }],
+  git: {
+    repos: [{ repo: repoId, path: "/root/app" }],
+  },
+});
+
+console.log(await vm.app.logs());
+```
+
+### Workspace API
+
+```typescript
+const workspace = bun.workspace({
+  path: "/root/app",
+  install: true,
+});
+```
+
+- `path`: Working directory for `bun install` and task execution.
+- `install`: When true, runs `bun install` in the workspace during VM startup.
+
+### Task API
+
+```typescript
+const task = workspace.task("dev", {
+  env: {
+    HOST: "0.0.0.0",
+    PORT: "3000",
+  },
+  serviceName: "my-bun-app",
+});
+```
+
+- `name`: Script name from `package.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

@@ -4,18 +4,64 @@ import { VmJavaScriptRuntimeInstance, JSONValue, RunCodeResponse, InstallOptions
 type BunJsOptions = {
     version?: string;
     workdir?: string;
+    deleteAfterSuccess?: boolean;
 };
 type BunJsResolvedOptions = {
     version?: string;
     workdir?: string;
+    deleteAfterSuccess: boolean;
 };
 declare class VmBun extends VmWith<VmBunInstance> implements VmJavaScriptRuntime<VmJavaScriptRuntimeInstance> {
     options: BunJsResolvedOptions;
+    workspaces: BunWorkspace[];
     constructor(options?: BunJsOptions);
     configureSnapshotSpec(spec: VmSpec): VmSpec;
     createInstance(): VmBunInstance;
+    workspace(options: {
+        path: string;
+        install?: boolean;
+    }): BunWorkspace;
     installServiceName(): string;
 }
+declare class BunWorkspace extends VmWith<BunWorkspaceInstance> {
+    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;
+    }): BunWorkspaceTask;
+    getInstallServiceName(): string;
+    configureSpec(spec: VmSpec): VmSpec;
+    createInstance(): BunWorkspaceInstance;
+}
+declare class BunWorkspaceInstance extends VmWithInstance {
+}
+declare class BunWorkspaceTask extends VmWith<BunWorkspaceTaskInstance> {
+    name: string;
+    workspace: BunWorkspace;
+    env?: Record<string, string>;
+    serviceName?: string;
+    constructor(name: string, workspace: BunWorkspace, env?: Record<string, string>, serviceName?: string);
+    getServiceName(): string;
+    configureSpec(spec: VmSpec): VmSpec;
+    createInstance(): BunWorkspaceTaskInstance;
+}
+declare class BunWorkspaceTaskInstance extends VmWithInstance {
+    name: string;
+    workspace: BunWorkspace;
+    env?: Record<string, string>;
+    serviceName?: string;
+    constructor(name: string, workspace: BunWorkspace, env?: Record<string, string>, serviceName?: string);
+    getServiceName(): string;
+    logs(): Promise<string[] | undefined>;
+}
 declare class VmBunInstance extends VmWithInstance implements VmJavaScriptRuntimeInstance {
     builder: VmBun;
     constructor(builder: VmBun);
@@ -28,4 +74,4 @@ declare class VmBunInstance extends VmWithInstance implements VmJavaScriptRuntim
     install(options?: InstallOptions): Promise<InstallResult>;
 }
 
-export { VmBun };
+export { BunWorkspace, BunWorkspaceInstance, BunWorkspaceTask, BunWorkspaceTaskInstance, VmBun };

package/dist/index.js

@@ -2,11 +2,13 @@ import { VmWith, VmSpec, VmWithInstance } from 'freestyle-sandboxes';
 
 class VmBun extends VmWith {
   options;
+  workspaces = [];
   constructor(options) {
     super();
     this.options = {
       version: options?.version,
-      workdir: options?.workdir
+      workdir: options?.workdir,
+      deleteAfterSuccess: options?.deleteAfterSuccess ?? true
     };
   }
   configureSnapshotSpec(spec) {
@@ -36,7 +38,7 @@ export PATH="$BUN_INSTALL/bin:$PATH"
             {
               name: "install-bun",
               mode: "oneshot",
-              deleteAfterSuccess: true,
+              deleteAfterSuccess: this.options.deleteAfterSuccess,
               env: {
                 HOME: "/root"
               },
@@ -51,10 +53,140 @@ export PATH="$BUN_INSTALL/bin:$PATH"
   createInstance() {
     return new VmBunInstance(this);
   }
+  workspace(options) {
+    const workspace = new BunWorkspace(options);
+    this.workspaces.push(workspace);
+    return workspace;
+  }
   installServiceName() {
     return "install-bun.service";
   }
 }
+class BunWorkspace extends VmWith {
+  options;
+  env;
+  constructor(options, env) {
+    super();
+    this.options = options;
+    this.env = env;
+  }
+  task(name, options) {
+    return new BunWorkspaceTask(
+      name,
+      this,
+      {
+        ...this.env,
+        ...options?.env
+      },
+      options?.serviceName
+    );
+  }
+  getInstallServiceName() {
+    return `bun-install-${this.options.path.replace(/\//g, "-")}`;
+  }
+  configureSpec(spec) {
+    if (this.options.install) {
+      return this.composeSpecs(
+        spec,
+        new VmSpec({
+          systemd: {
+            services: [
+              {
+                name: this.getInstallServiceName(),
+                mode: "oneshot",
+                exec: ["/opt/bun/bin/bun install"],
+                workdir: this.options.path,
+                env: {
+                  HOME: "/root",
+                  BUN_INSTALL: "/opt/bun",
+                  PATH: "/opt/bun/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+                  ...this.env
+                },
+                user: "root"
+              }
+            ]
+          }
+        })
+      );
+    }
+    return spec;
+  }
+  createInstance() {
+    return new BunWorkspaceInstance();
+  }
+}
+class BunWorkspaceInstance extends VmWithInstance {
+}
+class BunWorkspaceTask 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 ?? `bun-workspace-${this.workspace.options.path.replace(/\//g, "-")}-task-${this.name}`;
+  }
+  configureSpec(spec) {
+    return this.composeSpecs(
+      spec,
+      new VmSpec({
+        systemd: {
+          services: [
+            {
+              name: this.getServiceName(),
+              exec: [`/opt/bun/bin/bun run ${this.name}`],
+              workdir: this.workspace.options.path,
+              after: this.workspace.options.install ? [this.workspace.getInstallServiceName()] : void 0,
+              requires: this.workspace.options.install ? [this.workspace.getInstallServiceName()] : void 0,
+              env: {
+                HOME: "/root",
+                BUN_INSTALL: "/opt/bun",
+                PATH: "/opt/bun/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+                ...this.env
+              },
+              user: "root"
+            }
+          ]
+        }
+      })
+    );
+  }
+  createInstance() {
+    return new BunWorkspaceTaskInstance(
+      this.name,
+      this.workspace,
+      this.env,
+      this.serviceName
+    );
+  }
+}
+class BunWorkspaceTaskInstance 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 ?? `bun-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 VmBunInstance extends VmWithInstance {
   builder;
   constructor(builder) {
@@ -113,4 +245,4 @@ class VmBunInstance extends VmWithInstance {
   }
 }
 
-export { VmBun };
+export { BunWorkspace, BunWorkspaceInstance, BunWorkspaceTask, BunWorkspaceTaskInstance, VmBun };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@freestyle-sh/with-bun",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "private": false,
   "dependencies": {
-    "freestyle-sandboxes": "^0.1.28",
-    "@freestyle-sh/with-type-js": "^0.2.8"
+    "freestyle-sandboxes": "^0.1.41",
+    "@freestyle-sh/with-type-js": "^0.2.9"
   },
   "type": "module",
   "main": "./dist/index.js",