Watch a directory

Watch a directory when your application must react to files created or changed inside a running sandbox.

mjs

import { FilesystemEventType, Sandbox } from "@abox-dev/sdk";

const sandbox = await Sandbox.create();

try {
  let receiveEvent;
  const nextWrite = new Promise((resolve) => {
    receiveEvent = resolve;
  });

  const watcher = await sandbox.files.watchDir(
    "~",
    (event) => {
      if (event.type === FilesystemEventType.WRITE) receiveEvent(event);
    },
    { includeEntry: true, user: "root" },
  );

  await sandbox.files.write("~/message.txt", "Hello", { user: "root" });
  const event = await nextWrite;
  console.log(event.type, event.entry?.path);

  await watcher.stop();
} finally {
  await sandbox.kill();
}

from time import sleep

from agentbox import FilesystemEventType, Sandbox


sandbox = Sandbox.create()

try:
    watcher = sandbox.files.watch_dir("~", include_entry=True, user="root")
    sandbox.files.write("~/message.txt", "Hello", user="root")

    sleep(1)
    for event in watcher.get_new_events():
        if event.type == FilesystemEventType.WRITE:
            print(event.type.value, event.entry.path if event.entry else None)

    watcher.stop()
finally:
    sandbox.kill()

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func kill(sandbox *agentbox.Sandbox) {
	if _, err := sandbox.Kill(context.Background()); err != nil {
		log.Printf("cleanup sandbox: %v", err)
	}
}

func run() (err error) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, nil)
	if err != nil {
		return err
	}
	defer kill(sandbox)

	watch, err := sandbox.Files.Watch(ctx, "~", &agentbox.WatchOptions{IncludeEntry: true, User: "root"})
	if err != nil {
		return err
	}
	defer watch.Close()
	if _, err := sandbox.Files.WriteText(ctx, "~/message.txt", "Hello", &agentbox.WriteFileOptions{User: "root"}); err != nil {
		return err
	}
	for event := range watch.Events {
		if event.Type == "write" && event.Entry != nil {
			fmt.Println(event.Type, event.Entry.Path)
			break
		}
	}
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

JavaScript delivers events to the callback passed to watchDir. Python stores them until get_new_events() is called. Go exposes events through the WatchHandle.Events channel. Stop the watcher when it is no longer needed.

Set recursive to watch existing subdirectories. Set includeEntry in JavaScript, include_entry in Python, or IncludeEntry in Go to receive file information with an event. Entry information can be absent after a file is removed.

Watching a network filesystem requires the explicit allowNetworkMounts, allow_network_mounts, or AllowNetworkMounts option. Such events are best effort: changes made by a different client are not delivered to the sandbox watcher.

To resolve the watched path for a specific user, set user in JavaScript/Python or WatchOptions.User in Go. For example, watching ~ with user root selects root's home directory. An empty Go user uses the template default.

Watch a directory ​

Watch a directory