@freestyle-sh/with-pty 0.0.2

package/README.md

@@ -0,0 +1,79 @@
+# @freestyle-sh/with-pty
+
+Generic PTY helper for Freestyle VMs, backed by tmux.
+
+By default, PTY helpers also add `/root/.tmux.conf` with:
+
+```tmux
+set -g mouse on
+set -g status off
+```
+
+Set `applyDefaultTmuxConfig: false` to opt out.
+
+## Installation
+
+```bash
+pnpm add @freestyle-sh/with-pty freestyle-sandboxes
+```
+
+## Usage
+
+```ts
+import { freestyle, VmSpec } from "freestyle-sandboxes";
+import { VmPty } from "@freestyle-sh/with-pty";
+
+const { vm } = await freestyle.vms.create({
+  snapshot: new VmSpec({
+    with: {
+      pty: new VmPty(),
+    },
+  }),
+});
+
+const ptyHandle = await vm.pty.createPtySession({
+  id: "dev",
+  command: "npm run dev",
+  cwd: "/root/repo",
+  ptySize: { cols: 120, rows: 30 },
+  reset: true,
+});
+
+await ptyHandle.sendInput("echo hello from pty\n");
+
+await ptyHandle.resize({ cols: 160, rows: 40 });
+
+const sessions = await vm.pty.listPtySessions();
+console.log(sessions.map((s) => s.id));
+
+const output = await ptyHandle.read({
+  lines: 80,
+});
+
+console.log(output);
+
+const result = await ptyHandle.wait({ timeoutMs: 5_000 });
+console.log(result.exitCode);
+```
+
+## API
+
+- Process-level methods:
+  - `createPtySession({ id, command, cwd, envs, ptySize, reset })`
+  - `connectPtySession(sessionId)`
+  - `listPtySessions()`
+  - `getPtySessionInfo(sessionId)`
+  - `resizePtySession(sessionId, ptySize)`
+  - `killPtySession(sessionId)`
+  - `attachCommand({ sessionId, readOnly })`
+- Handle methods (`PtyHandle`):
+  - `sendInput(data)`
+  - `read({ lines, includeEscape })`
+  - `resize(ptySize)`
+  - `wait({ timeoutMs, pollIntervalMs, lines, onData })`
+  - `waitForConnection(timeoutMs)`
+  - `isConnected()`
+  - `disconnect()`
+  - `kill()`
+
+Note: This implementation uses tmux under the hood. It mirrors Daytona-style semantics where practical, but does not expose a websocket stream; `wait`/`read` use polling via tmux capture.

package/dist/index.d.ts

@@ -0,0 +1,140 @@
+import { VmWith, VmWithInstance, VmSpec } from 'freestyle-sandboxes';
+
+type VmPtyOptions = {
+    installTmux?: boolean;
+    defaultWorkdir?: string;
+    applyDefaultTmuxConfig?: boolean;
+};
+type PtySize = {
+    cols: number;
+    rows: number;
+};
+type CreatePtySessionOptions = {
+    id: string;
+    command?: string;
+    cwd?: string;
+    envs?: Record<string, string>;
+    ptySize?: PtySize;
+    reset?: boolean;
+};
+type PtySessionInfo = {
+    id: string;
+    active: boolean;
+    cwd: string;
+    cols: number;
+    rows: number;
+    createdAt: number;
+};
+type PtyReadOptions = {
+    lines?: number;
+    includeEscape?: boolean;
+};
+type PtyWaitOptions = {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    lines?: number;
+    onData?: (data: string) => void;
+};
+type PtyWaitResult = {
+    exitCode: number | null;
+    error?: string;
+    output?: string;
+};
+type VmPtySessionOptions = {
+    sessionId: string;
+    resetSession?: boolean;
+    cols?: number;
+    rows?: number;
+    envs?: Record<string, string>;
+    installTmux?: boolean;
+    workdir?: string;
+    applyDefaultTmuxConfig?: boolean;
+};
+type VmPtySessionLike = {
+    attachCommand(readOnly?: boolean): string;
+    wrapCommand(command: string, workdir?: string): string;
+    wrapServiceCommand(command: string, workdir?: string): string;
+    applyToSpec(spec: unknown): unknown;
+    captureOutputCommand(options?: PtyReadOptions): string;
+};
+declare class VmPty extends VmWith<VmPtyInstance> {
+    options: Required<VmPtyOptions>;
+    constructor(options?: VmPtyOptions);
+    configureSnapshotSpec(spec: VmSpec): VmSpec;
+    createInstance(): VmPtyInstance;
+}
+declare class VmPtySession extends VmWith<VmPtySessionInstance> {
+    options: Required<Pick<VmPtySessionOptions, "sessionId" | "resetSession" | "installTmux" | "workdir" | "applyDefaultTmuxConfig">> & Pick<VmPtySessionOptions, "cols" | "rows" | "envs">;
+    constructor(options: VmPtySessionOptions);
+    private shellEscape;
+    private validateEnvKey;
+    configureSnapshotSpec(spec: VmSpec): VmSpec;
+    applyToSpec(spec: unknown): unknown;
+    createInstance(): VmPtySessionInstance;
+    attachCommand(readOnly?: boolean): string;
+    private buildDetachedTmuxCommand;
+    private buildResetCommand;
+    wrapCommand(command: string, workdir?: string): string;
+    wrapServiceCommand(command: string, workdir?: string): string;
+    captureOutputCommand(options?: PtyReadOptions): string;
+}
+declare class VmPtySessionInstance extends VmWithInstance {
+    builder: VmPtySession;
+    constructor(builder: VmPtySession);
+    private shellEscape;
+    sendInput(data: string): Promise<ExecResult>;
+    readOutput(options?: PtyReadOptions): Promise<string>;
+    kill(): Promise<void>;
+}
+type ExecResult = {
+    statusCode?: number | undefined | null;
+    stdout?: string | undefined | null;
+    stderr?: string | undefined | null;
+};
+declare class VmPtyInstance extends VmWithInstance {
+    builder: VmPty;
+    private readonly stateDir;
+    constructor(builder: VmPty);
+    private shellEscape;
+    private validateSessionId;
+    private validateEnvKey;
+    private hasPtySession;
+    private exitCodePath;
+    readExitCode(id: string): Promise<number | null>;
+    createPtySession(options: CreatePtySessionOptions): Promise<PtyHandle>;
+    connectPtySession(sessionId: string): Promise<PtyHandle>;
+    listPtySessions(): Promise<PtySessionInfo[]>;
+    getPtySessionInfo(sessionId: string): Promise<PtySessionInfo>;
+    killPtySession(sessionId: string): Promise<void>;
+    resizePtySession(sessionId: string, ptySize: PtySize): Promise<PtySessionInfo>;
+    sendInput(sessionId: string, data: string): Promise<ExecResult>;
+    readOutput(sessionId: string, options?: PtyReadOptions): Promise<string>;
+    isSessionConnected(sessionId: string): Promise<boolean>;
+    attachCommand(options: {
+        sessionId: string;
+        readOnly?: boolean;
+    }): string;
+}
+declare class PtyHandle {
+    readonly sessionId: string;
+    readonly process: VmPtyInstance;
+    exitCode: number | null;
+    error?: string;
+    private disconnected;
+    constructor({ process, sessionId, }: {
+        process: VmPtyInstance;
+        sessionId: string;
+    });
+    private ensureConnected;
+    sendInput(data: string): Promise<void>;
+    read(options?: PtyReadOptions): Promise<string>;
+    resize(ptySize: PtySize): Promise<PtySessionInfo>;
+    waitForConnection(timeoutMs?: number): Promise<void>;
+    wait(options?: PtyWaitOptions): Promise<PtyWaitResult>;
+    kill(): Promise<void>;
+    disconnect(): void;
+    isConnected(): Promise<boolean>;
+}
+
+export { PtyHandle, VmPty, VmPtyInstance, VmPtySession, VmPtySessionInstance };
+export type { CreatePtySessionOptions, PtyReadOptions, PtySessionInfo, PtySize, PtyWaitOptions, PtyWaitResult, VmPtyOptions, VmPtySessionLike, VmPtySessionOptions };

package/dist/index.js

@@ -0,0 +1,439 @@
+import { VmWith, VmSpec, VmWithInstance } from 'freestyle-sandboxes';
+
+const DEFAULT_TMUX_CONF = `set -g mouse on
+set -g status off`;
+class VmPty extends VmWith {
+  options;
+  constructor(options) {
+    super();
+    this.options = {
+      installTmux: options?.installTmux ?? true,
+      defaultWorkdir: options?.defaultWorkdir ?? "/root",
+      applyDefaultTmuxConfig: options?.applyDefaultTmuxConfig ?? true
+    };
+  }
+  configureSnapshotSpec(spec) {
+    if (!this.options.installTmux && !this.options.applyDefaultTmuxConfig) {
+      return spec;
+    }
+    return this.composeSpecs(
+      spec,
+      new VmSpec({
+        aptDeps: this.options.installTmux ? ["tmux"] : void 0,
+        additionalFiles: this.options.applyDefaultTmuxConfig ? {
+          "/root/.tmux.conf": {
+            content: DEFAULT_TMUX_CONF
+          }
+        } : void 0
+      })
+    );
+  }
+  createInstance() {
+    return new VmPtyInstance(this);
+  }
+}
+class VmPtySession extends VmWith {
+  options;
+  constructor(options) {
+    super();
+    if (!/^[a-zA-Z0-9._-]+$/.test(options.sessionId)) {
+      throw new Error(
+        "Invalid PTY session id. Use only letters, numbers, dot, underscore, and hyphen."
+      );
+    }
+    this.options = {
+      sessionId: options.sessionId,
+      resetSession: options.resetSession ?? true,
+      cols: options.cols,
+      rows: options.rows,
+      envs: options.envs,
+      installTmux: options.installTmux ?? true,
+      workdir: options.workdir ?? "/root",
+      applyDefaultTmuxConfig: options.applyDefaultTmuxConfig ?? true
+    };
+  }
+  shellEscape(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+  }
+  validateEnvKey(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new Error(`Invalid env var name: ${key}`);
+    }
+  }
+  configureSnapshotSpec(spec) {
+    return this.applyToSpec(spec);
+  }
+  applyToSpec(spec) {
+    const typedSpec = spec;
+    if (!this.options.installTmux && !this.options.applyDefaultTmuxConfig) {
+      return typedSpec;
+    }
+    return this.composeSpecs(
+      typedSpec,
+      new VmSpec({
+        aptDeps: this.options.installTmux ? ["tmux"] : void 0,
+        additionalFiles: this.options.applyDefaultTmuxConfig ? {
+          "/root/.tmux.conf": {
+            content: DEFAULT_TMUX_CONF
+          }
+        } : void 0
+      })
+    );
+  }
+  createInstance() {
+    return new VmPtySessionInstance(this);
+  }
+  attachCommand(readOnly = false) {
+    const flag = readOnly ? "-r " : "";
+    return `tmux attach ${flag}-t ${this.options.sessionId}`;
+  }
+  buildDetachedTmuxCommand(command, workdir) {
+    const envPrefix = Object.entries(this.options.envs ?? {}).map(([key, value]) => {
+      this.validateEnvKey(key);
+      return `${key}=${this.shellEscape(value)}`;
+    }).join(" ");
+    const runCommand = `${envPrefix ? `${envPrefix} ` : ""}${command}`;
+    return [
+      "tmux new-session -d",
+      `-s ${this.shellEscape(this.options.sessionId)}`,
+      `-c ${this.shellEscape(workdir ?? this.options.workdir)}`,
+      this.options.cols ? `-x ${this.options.cols}` : "",
+      this.options.rows ? `-y ${this.options.rows}` : "",
+      this.shellEscape(`bash -lc ${this.shellEscape(runCommand)}`)
+    ].filter(Boolean).join(" ");
+  }
+  buildResetCommand() {
+    return this.options.resetSession ? `tmux has-session -t ${this.shellEscape(this.options.sessionId)} >/dev/null 2>&1 && tmux kill-session -t ${this.shellEscape(this.options.sessionId)} || true` : "true";
+  }
+  wrapCommand(command, workdir) {
+    const tmuxCommand = this.buildDetachedTmuxCommand(command, workdir);
+    const resetCommand = this.buildResetCommand();
+    return `bash -lc ${this.shellEscape(`set -e
+${resetCommand}
+${tmuxCommand}`)}`;
+  }
+  wrapServiceCommand(command, workdir) {
+    const tmuxCommand = this.buildDetachedTmuxCommand(command, workdir);
+    const resetCommand = this.buildResetCommand();
+    return `bash -lc ${this.shellEscape(`set -e
+${resetCommand}
+${tmuxCommand}
+while tmux has-session -t ${this.shellEscape(this.options.sessionId)} >/dev/null 2>&1; do
+  sleep 1
+done`)}`;
+  }
+  captureOutputCommand(options) {
+    const lines = options?.lines ?? 200;
+    const includeEscape = options?.includeEscape ?? true;
+    return [
+      "tmux capture-pane",
+      includeEscape ? "-e" : "",
+      "-p",
+      `-t ${this.shellEscape(this.options.sessionId)}`,
+      `-S -${lines}`
+    ].filter(Boolean).join(" ");
+  }
+}
+class VmPtySessionInstance extends VmWithInstance {
+  builder;
+  constructor(builder) {
+    super();
+    this.builder = builder;
+  }
+  shellEscape(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+  }
+  async sendInput(data) {
+    return this.vm.exec({
+      command: `tmux set-buffer -- ${this.shellEscape(data)} && tmux paste-buffer -d -t ${this.shellEscape(this.builder.options.sessionId)}`
+    });
+  }
+  async readOutput(options) {
+    const lines = options?.lines ?? 200;
+    const includeEscape = options?.includeEscape ?? true;
+    const capture = [
+      "tmux capture-pane",
+      includeEscape ? "-e" : "",
+      "-p",
+      `-t ${this.shellEscape(this.builder.options.sessionId)}`,
+      `-S -${lines}`
+    ].filter(Boolean).join(" ");
+    const result = await this.vm.exec({ command: capture });
+    return result.stdout ?? "";
+  }
+  async kill() {
+    await this.vm.exec({
+      command: `tmux has-session -t ${this.shellEscape(this.builder.options.sessionId)} >/dev/null 2>&1 && tmux kill-session -t ${this.shellEscape(this.builder.options.sessionId)} || true`
+    });
+  }
+}
+class VmPtyInstance extends VmWithInstance {
+  builder;
+  stateDir = "/tmp/freestyle-pty";
+  constructor(builder) {
+    super();
+    this.builder = builder;
+  }
+  shellEscape(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+  }
+  validateSessionId(id) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(id)) {
+      throw new Error(
+        "Invalid PTY session id. Use only letters, numbers, dot, underscore, and hyphen."
+      );
+    }
+  }
+  validateEnvKey(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new Error(`Invalid env var name: ${key}`);
+    }
+  }
+  async hasPtySession(id) {
+    const result = await this.vm.exec({
+      command: `tmux has-session -t ${this.shellEscape(id)}`
+    });
+    return result.statusCode === 0;
+  }
+  exitCodePath(id) {
+    return `${this.stateDir}/${id}.exit`;
+  }
+  async readExitCode(id) {
+    const path = this.exitCodePath(id);
+    const result = await this.vm.exec({
+      command: `if [ -f ${this.shellEscape(path)} ]; then cat ${this.shellEscape(path)}; fi`
+    });
+    const raw = (result.stdout ?? "").trim();
+    if (!raw) {
+      return null;
+    }
+    const value = Number.parseInt(raw, 10);
+    return Number.isNaN(value) ? null : value;
+  }
+  async createPtySession(options) {
+    this.validateSessionId(options.id);
+    const command = options.command ?? "bash -l";
+    const cwd = options.cwd ?? this.builder.options.defaultWorkdir;
+    const size = options.ptySize;
+    const envPrefix = Object.entries(options.envs ?? {}).map(([key, value]) => {
+      this.validateEnvKey(key);
+      return `export ${key}=${this.shellEscape(value)};`;
+    }).join(" ");
+    const exitPath = this.exitCodePath(options.id);
+    const wrappedCommand = `${envPrefix} ${command}; __pty_status=$?; printf '%s' "$__pty_status" > ${this.shellEscape(exitPath)}; exit "$__pty_status"`;
+    const parts = [
+      `mkdir -p ${this.shellEscape(this.stateDir)}`,
+      `rm -f ${this.shellEscape(exitPath)}`
+    ];
+    if (options.reset) {
+      parts.push(
+        `tmux has-session -t ${this.shellEscape(options.id)} >/dev/null 2>&1 && tmux kill-session -t ${this.shellEscape(options.id)} || true`
+      );
+    }
+    parts.push(
+      [
+        "tmux new-session -d",
+        `-s ${this.shellEscape(options.id)}`,
+        `-c ${this.shellEscape(cwd)}`,
+        size ? `-x ${size.cols}` : "",
+        size ? `-y ${size.rows}` : "",
+        this.shellEscape(`bash -lc ${this.shellEscape(wrappedCommand)}`)
+      ].filter(Boolean).join(" ")
+    );
+    const result = await this.vm.exec({ command: parts.join(" && ") });
+    if (result.statusCode && result.statusCode !== 0) {
+      throw new Error(
+        result.stderr ?? `Failed to create PTY session ${options.id}`
+      );
+    }
+    return new PtyHandle({
+      process: this,
+      sessionId: options.id
+    });
+  }
+  async connectPtySession(sessionId) {
+    this.validateSessionId(sessionId);
+    const exists = await this.hasPtySession(sessionId);
+    if (!exists) {
+      throw new Error(`PTY session ${sessionId} not found`);
+    }
+    return new PtyHandle({
+      process: this,
+      sessionId
+    });
+  }
+  async listPtySessions() {
+    const listResult = await this.vm.exec({
+      command: "tmux list-sessions -F '#{session_name}' 2>/dev/null || true"
+    });
+    const ids = (listResult.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    const infos = [];
+    for (const id of ids) {
+      infos.push(await this.getPtySessionInfo(id));
+    }
+    return infos;
+  }
+  async getPtySessionInfo(sessionId) {
+    this.validateSessionId(sessionId);
+    const active = await this.hasPtySession(sessionId);
+    if (!active) {
+      throw new Error(`PTY session ${sessionId} not found`);
+    }
+    const raw = (await this.vm.exec({
+      command: `tmux display-message -p -t ${this.shellEscape(sessionId)} '#{pane_current_path}	#{window_width}	#{window_height}	#{session_created}'`
+    })).stdout;
+    const [cwd = "", width = "80", height = "24", created = "0"] = (raw ?? "").trim().split("	");
+    return {
+      id: sessionId,
+      active,
+      cwd,
+      cols: Number.parseInt(width, 10) || 80,
+      rows: Number.parseInt(height, 10) || 24,
+      createdAt: Number.parseInt(created, 10) || 0
+    };
+  }
+  async killPtySession(sessionId) {
+    this.validateSessionId(sessionId);
+    await this.vm.exec({
+      command: `tmux has-session -t ${this.shellEscape(sessionId)} >/dev/null 2>&1 && tmux kill-session -t ${this.shellEscape(sessionId)} || true`
+    });
+  }
+  async resizePtySession(sessionId, ptySize) {
+    this.validateSessionId(sessionId);
+    await this.vm.exec({
+      command: `tmux resize-window -t ${this.shellEscape(sessionId)} -x ${ptySize.cols} -y ${ptySize.rows}`
+    });
+    return this.getPtySessionInfo(sessionId);
+  }
+  async sendInput(sessionId, data) {
+    this.validateSessionId(sessionId);
+    return this.vm.exec({
+      command: `tmux set-buffer -- ${this.shellEscape(data)} && tmux paste-buffer -d -t ${this.shellEscape(sessionId)}`
+    });
+  }
+  async readOutput(sessionId, options) {
+    this.validateSessionId(sessionId);
+    const lines = options?.lines ?? 200;
+    const includeEscape = options?.includeEscape ?? true;
+    const capture = [
+      "tmux capture-pane",
+      includeEscape ? "-e" : "",
+      "-p",
+      `-t ${this.shellEscape(sessionId)}`,
+      `-S -${lines}`
+    ].filter(Boolean).join(" ");
+    const result = await this.vm.exec({ command: capture });
+    return result.stdout ?? "";
+  }
+  async isSessionConnected(sessionId) {
+    return this.hasPtySession(sessionId);
+  }
+  attachCommand(options) {
+    const flag = options.readOnly ? "-r " : "";
+    return `tmux attach ${flag}-t ${options.sessionId}`;
+  }
+}
+class PtyHandle {
+  sessionId;
+  process;
+  exitCode = null;
+  error;
+  disconnected = false;
+  constructor({
+    process,
+    sessionId
+  }) {
+    this.process = process;
+    this.sessionId = sessionId;
+  }
+  ensureConnected() {
+    if (this.disconnected) {
+      throw new Error(`PTY handle for ${this.sessionId} is disconnected`);
+    }
+  }
+  async sendInput(data) {
+    this.ensureConnected();
+    const result = await this.process.sendInput(this.sessionId, data);
+    if (result.statusCode && result.statusCode !== 0) {
+      throw new Error(
+        result.stderr ?? `Failed to send input to ${this.sessionId}`
+      );
+    }
+  }
+  async read(options) {
+    this.ensureConnected();
+    return this.process.readOutput(this.sessionId, options);
+  }
+  async resize(ptySize) {
+    this.ensureConnected();
+    return this.process.resizePtySession(this.sessionId, ptySize);
+  }
+  async waitForConnection(timeoutMs = 1e4) {
+    this.ensureConnected();
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (await this.process.isSessionConnected(this.sessionId)) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(
+      `Timed out waiting for PTY session ${this.sessionId} connection`
+    );
+  }
+  async wait(options) {
+    this.ensureConnected();
+    const timeoutMs = options?.timeoutMs;
+    const pollIntervalMs = options?.pollIntervalMs ?? 500;
+    const start = Date.now();
+    let previousOutput = "";
+    while (true) {
+      const output = await this.process.readOutput(this.sessionId, {
+        lines: options?.lines ?? 300,
+        includeEscape: true
+      });
+      if (options?.onData) {
+        const delta = output.startsWith(previousOutput) ? output.slice(previousOutput.length) : output;
+        if (delta.length > 0) {
+          options.onData(delta);
+        }
+      }
+      previousOutput = output;
+      const connected = await this.process.isSessionConnected(this.sessionId);
+      if (!connected) {
+        this.disconnected = true;
+        const exitCode = await this.process.readExitCode(this.sessionId);
+        this.exitCode = exitCode;
+        return {
+          exitCode,
+          output: previousOutput,
+          error: this.error
+        };
+      }
+      if (timeoutMs !== void 0 && Date.now() - start >= timeoutMs) {
+        this.error = "Timed out waiting for PTY session completion";
+        return {
+          exitCode: null,
+          output: previousOutput,
+          error: this.error
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+  async kill() {
+    await this.process.killPtySession(this.sessionId);
+    this.disconnected = true;
+  }
+  disconnect() {
+    this.disconnected = true;
+  }
+  async isConnected() {
+    if (this.disconnected) {
+      return false;
+    }
+    return this.process.isSessionConnected(this.sessionId);
+  }
+}
+
+export { PtyHandle, VmPty, VmPtyInstance, VmPtySession, VmPtySessionInstance };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@freestyle-sh/with-pty",
+  "version": "0.0.2",
+  "private": false,
+  "dependencies": {
+    "freestyle-sandboxes": "^0.1.28"
+  },
+  "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"
+  ],
+  "devDependencies": {
+    "pkgroll": "^2.11.2",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "pkgroll"
+  }
+}