@gitterm/opencode-sandbox 0.0.0-stage → 0.1.1

package/dist/sandbox.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from "@opencode/plugin";
+import { type SandboxSettings } from "@gitterm/sdk/sandbox";
+/**
+ * Remote sandbox tools for a local conversation. The conversation and local files stay
+ * here; commands run in a separate sandbox with no coding agent or model credentials.
+ * Nothing here replaces local shell execution or calls `/cloud`.
+ */
+type SetupContext = Plugin.Context;
+export declare function registerSandboxTools(ctx: SetupContext, settings: SandboxSettings | undefined, 
+/** Tests shorten the job watch interval. */
+watchIntervalMs?: number): Promise<() => Promise<void>>;
+export {};

package/dist/sidebar.d.ts

@@ -0,0 +1,10 @@
+import type { SandboxRecord } from "@gitterm/sdk/sandbox/store";
+export type SidebarRow = {
+    id: string;
+    title: string;
+    detail: string;
+    state: SandboxRecord["state"];
+};
+/** Live sandboxes for one checkout, newest first, as short sidebar lines. */
+export declare function sidebarRows(records: SandboxRecord[], project: string, now?: number): SidebarRow[];
+export declare function truncate(text: string, width: number): string;

package/dist/tui.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode/plugin/tui";
+declare const _default: Plugin.Definition;
+export default _default;

package/dist/tui.js

@@ -0,0 +1,218 @@
+// @bun
+// src/tui.tsx
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { realpath } from "fs/promises";
+import { Plugin, usePlugin } from "@opencode/plugin/tui";
+
+// ../sdk/dist/sandbox/store.js
+import { createHash, randomBytes } from "crypto";
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+function defaultStoreDirectory() {
+  const base = process.env.XDG_STATE_HOME || path.join(homedir(), ".local", "state");
+  return path.join(base, "gitterm", "sandboxes");
+}
+var fileName = (ref) => `${ref.mode}-${ref.provider}-${ref.account}-${ref.id}`.replace(/[^A-Za-z0-9_.-]/g, "_") + ".json";
+var snapshotFile = (id, root) => `${id.replace(/[^A-Za-z0-9_]/g, "")}-${createHash("sha256").update(root).digest("hex").slice(0, 16)}.json`;
+var LOCK_STALE_MS = 30000;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function withFileLock(target, action) {
+  const lock = `${target}.lock`;
+  const deadline = Date.now() + 2 * LOCK_STALE_MS;
+  while (true) {
+    try {
+      await writeFile(lock, String(process.pid), { flag: "wx", mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      const age = await stat(lock).then((info) => Date.now() - info.mtimeMs, () => 0);
+      if (age > LOCK_STALE_MS)
+        await rm(lock, { force: true });
+      else if (Date.now() > deadline)
+        throw new Error(`Timed out waiting for ${lock}`);
+      else
+        await sleep(5 + Math.random() * 20);
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    await rm(lock, { force: true });
+  }
+}
+function createFileSandboxStore(directory = defaultStoreDirectory()) {
+  const read = async (file) => JSON.parse(await readFile(path.join(directory, file), "utf8"));
+  const write = async (target, record) => {
+    const temporary = `${target}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+      await writeFile(temporary, JSON.stringify(record, null, 2), { mode: 384 });
+      await rename(temporary, target);
+    } finally {
+      await rm(temporary, { force: true });
+    }
+  };
+  const queues = new Map;
+  const serialized = (target, action) => {
+    const next = (queues.get(target) ?? Promise.resolve()).catch(() => {}).then(() => withFileLock(target, action));
+    queues.set(target, next);
+    next.then(() => queues.get(target) === next && queues.delete(target), () => queues.get(target) === next && queues.delete(target));
+    return next;
+  };
+  return {
+    async list() {
+      const files = await readdir(directory).catch(() => []);
+      const records = await Promise.all(files.filter((file) => file.endsWith(".json")).map((file) => read(file).catch(() => null)));
+      return records.filter((record) => record !== null);
+    },
+    async get(ref) {
+      return read(fileName(ref)).catch(() => null);
+    },
+    async put(record) {
+      await mkdir(directory, { recursive: true, mode: 448 });
+      const target = path.join(directory, fileName(record));
+      await serialized(target, () => write(target, record));
+    },
+    async update(ref, mutate, create) {
+      await mkdir(directory, { recursive: true, mode: 448 });
+      const target = path.join(directory, fileName(ref));
+      return serialized(target, async () => {
+        const current = await read(fileName(ref)).catch(() => null) ?? create?.() ?? null;
+        if (!current)
+          return null;
+        mutate(current);
+        current.updatedAt = new Date().toISOString();
+        await write(target, current);
+        return current;
+      });
+    },
+    async remove(ref) {
+      await rm(path.join(directory, fileName(ref)), { force: true });
+    },
+    async putSnapshot(snapshot) {
+      const target = path.join(directory, "snapshots", snapshotFile(snapshot.id, snapshot.root));
+      await mkdir(path.dirname(target), { recursive: true, mode: 448 });
+      await writeFile(target, JSON.stringify(snapshot), { mode: 384 });
+    },
+    async getSnapshot(id, root) {
+      return readFile(path.join(directory, "snapshots", snapshotFile(id, root)), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    }
+  };
+}
+
+// src/tui.tsx
+import { createSignal, For, onCleanup, onMount, Show } from "solid-js";
+
+// src/sidebar.ts
+function sidebarRows(records, project, now = Date.now()) {
+  return records.filter((record) => record.project === project && record.state !== "terminated" && !(record.expiresAt && Date.parse(record.expiresAt) <= now)).toSorted((a, b) => b.createdAt.localeCompare(a.createdAt)).map((record) => {
+    const running = Object.values(record.jobs).filter((job) => job.status === "running").length;
+    const detail = [
+      record.state === "running" ? "" : record.state,
+      running ? `${running} running` : "",
+      ...Object.values(record.previews).map((preview) => `:${preview.port}`),
+      record.purpose || record.provider
+    ].filter(Boolean).join(" \xB7 ");
+    return { id: record.id, title: record.name, detail, state: record.state };
+  });
+}
+function truncate(text, width) {
+  return text.length > width ? `${text.slice(0, width - 1)}\u2026` : text;
+}
+
+// src/tui.tsx
+var REFRESH_MS = 3000;
+var WIDTH = 34;
+function SandboxSidebar(props) {
+  const context = usePlugin();
+  const theme = () => context.theme;
+  const [rows, setRows] = createSignal([]);
+  onMount(() => {
+    const store = createFileSandboxStore();
+    let disposed = false;
+    const refresh = async () => {
+      const directory = context.data.session.get(props.sessionID)?.location.directory;
+      if (!directory)
+        return;
+      const project = await realpath(directory).catch(() => directory);
+      const next = sidebarRows(await store.list(), project);
+      if (!disposed)
+        setRows(next);
+    };
+    refresh();
+    const timer = setInterval(() => void refresh(), REFRESH_MS);
+    onCleanup(() => {
+      disposed = true;
+      clearInterval(timer);
+    });
+  });
+  const dot = (state) => state === "running" ? theme().text.feedback.success.base : state === "deleting" ? theme().text.feedback.error.base : theme().text.feedback.warning.base;
+  return _$createComponent(Show, {
+    get when() {
+      return rows().length > 0;
+    },
+    get children() {
+      var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("b");
+      _$insertNode(_el$, _el$2);
+      _$setProp(_el$, "flexDirection", "column");
+      _$insertNode(_el$2, _el$3);
+      _$insertNode(_el$3, _$createTextNode(`Sandboxes`));
+      _$insert(_el$, _$createComponent(For, {
+        get each() {
+          return rows();
+        },
+        children: (row) => (() => {
+          var _el$5 = _$createElement("box"), _el$6 = _$createElement("text"), _el$7 = _$createElement("span"), _el$9 = _$createTextNode(` `), _el$0 = _$createElement("text"), _el$1 = _$createTextNode(` `);
+          _$insertNode(_el$5, _el$6);
+          _$insertNode(_el$5, _el$0);
+          _$setProp(_el$5, "flexDirection", "column");
+          _$insertNode(_el$6, _el$7);
+          _$insertNode(_el$6, _el$9);
+          _$insertNode(_el$7, _$createTextNode(`\u2022`));
+          _$insert(_el$6, () => truncate(row.title, WIDTH - 2), null);
+          _$insertNode(_el$0, _el$1);
+          _$insert(_el$0, () => truncate(row.detail, WIDTH - 2), null);
+          _$effect((_p$) => {
+            var _v$ = theme().text.base, _v$2 = {
+              fg: dot(row.state)
+            }, _v$3 = theme().text.muted;
+            _v$ !== _p$.e && (_p$.e = _$setProp(_el$6, "fg", _v$, _p$.e));
+            _v$2 !== _p$.t && (_p$.t = _$setProp(_el$7, "style", _v$2, _p$.t));
+            _v$3 !== _p$.a && (_p$.a = _$setProp(_el$0, "fg", _v$3, _p$.a));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined
+          });
+          return _el$5;
+        })()
+      }), null);
+      _$effect((_$p) => _$setProp(_el$2, "fg", theme().text.base, _$p));
+      return _el$;
+    }
+  });
+}
+var tui_default = Plugin.define({
+  id: "gitterm.sandbox",
+  setup(context) {
+    return context.ui.slot({
+      append: "sidebar.content",
+      render: (input) => _$createComponent(SandboxSidebar, {
+        get sessionID() {
+          return input.sessionID;
+        }
+      })
+    });
+  }
+});
+export {
+  tui_default as default
+};

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@gitterm/opencode-sandbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Let your OpenCode agent run builds, tests, and previews in remote sandboxes while the session stays local",
+  "keywords": [
+    "e2b",
+    "gitterm",
+    "opencode",
+    "opencode-plugin",
+    "remote-execution",
+    "sandbox",
+    "tui"
+  ],
+  "homepage": "https://gitterm.dev",
+  "license": "MIT",
+  "author": "Opeyemi Oginni",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js",
+      "default": "./dist/tui.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts --outdir dist --target bun --format esm --external @opencode/plugin && bun run build-tui.ts && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "prepack": "bun run check-types && bun run build"
+  },
+  "devDependencies": {
+    "@gitterm/sdk": "workspace:*",
+    "@opencode/plugin": "^2.2.6",
+    "@opentui/core": "0.8.0",
+    "@opentui/solid": "0.8.0",
+    "@types/bun": "^1.2.6",
+    "solid-js": "1.9.17",
+    "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "@opencode/plugin": "^2.2.6",
+    "@opentui/core": ">=0.8.0",
+    "@opentui/solid": ">=0.8.0",
+    "solid-js": ">=1.9.0"
+  },
+  "engines": {
+    "bun": ">=1.2.0"
+  }
+}