@wangjiehu/sandbox 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+interface FileBackup {
+    path: string;
+    originalContent: string | null;
+    originalHash?: string;
+}
+interface Checkpoint {
+    id: string;
+    sessionId: string;
+    timestamp: string;
+    toolCallId: string;
+    backups: FileBackup[];
+}
+
+declare class CheckpointManager {
+    private cwd;
+    private sessionId;
+    private checkpoints;
+    constructor(cwd: string, sessionId: string);
+    captureBeforeState(toolCallId: string, filePath: string): Promise<Checkpoint>;
+    getCheckpoints(): Checkpoint[];
+}
+
+declare class RollbackManager {
+    private cwd;
+    constructor(cwd: string);
+    rollback(checkpoint: Checkpoint): {
+        success: boolean;
+        error?: string;
+        restored: string[];
+    };
+}
+
+export { type Checkpoint, CheckpointManager, type FileBackup, RollbackManager };

package/dist/index.js

@@ -0,0 +1,98 @@
+// src/CheckpointManager.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { generateId, resolveSafePath } from "@wangjiehu/shared";
+var CheckpointManager = class {
+  constructor(cwd, sessionId) {
+    this.cwd = cwd;
+    this.sessionId = sessionId;
+  }
+  cwd;
+  sessionId;
+  checkpoints = [];
+  async captureBeforeState(toolCallId, filePath) {
+    let originalContent = null;
+    try {
+      const safePath = resolveSafePath(this.cwd, filePath);
+      if (existsSync(safePath)) {
+        originalContent = readFileSync(safePath, "utf8");
+      }
+    } catch (e) {
+    }
+    const backup = {
+      path: filePath,
+      originalContent
+    };
+    const checkpoint = {
+      id: generateId("cp"),
+      sessionId: this.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolCallId,
+      backups: [backup]
+    };
+    this.checkpoints.push(checkpoint);
+    const checkpointDir = join(
+      this.cwd,
+      ".orbit",
+      "checkpoints",
+      this.sessionId,
+      checkpoint.id
+    );
+    mkdirSync(checkpointDir, { recursive: true });
+    if (originalContent !== null) {
+      writeFileSync(
+        join(checkpointDir, "backup_content.txt"),
+        originalContent,
+        "utf8"
+      );
+    }
+    writeFileSync(
+      join(checkpointDir, "meta.json"),
+      JSON.stringify({
+        id: checkpoint.id,
+        timestamp: checkpoint.timestamp,
+        toolCallId,
+        filePath,
+        exists: originalContent !== null
+      }),
+      "utf8"
+    );
+    return checkpoint;
+  }
+  getCheckpoints() {
+    return this.checkpoints;
+  }
+};
+
+// src/RollbackManager.ts
+import { existsSync as existsSync2, writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { resolveSafePath as resolveSafePath2 } from "@wangjiehu/shared";
+var RollbackManager = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  rollback(checkpoint) {
+    const restored = [];
+    for (const backup of checkpoint.backups) {
+      const safePath = resolveSafePath2(this.cwd, backup.path);
+      if (backup.originalContent === null) {
+        if (existsSync2(safePath)) {
+          unlinkSync(safePath);
+          restored.push(backup.path);
+        }
+      } else {
+        writeFileSync2(safePath, backup.originalContent, "utf8");
+        restored.push(backup.path);
+      }
+    }
+    return {
+      success: true,
+      restored
+    };
+  }
+};
+export {
+  CheckpointManager,
+  RollbackManager
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@wangjiehu/sandbox",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@wangjiehu/config": "0.1.0",
+    "@wangjiehu/shared": "0.1.0",
+    "@wangjiehu/tools": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}

package/src/Checkpoint.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, writeFileSync, readFileSync, rmSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { CheckpointManager } from "./CheckpointManager.js";
+import { RollbackManager } from "./RollbackManager.js";
+
+describe("Sandbox Checkpoints and Rollbacks", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `orbit-sandbox-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should capture JIT snapshot before edit and rollback successfully", async () => {
+    const filePath = "test.txt";
+    const absPath = join(tempDir, filePath);
+
+    writeFileSync(absPath, "initial-content", "utf8");
+
+    const cpManager = new CheckpointManager(tempDir, "session-123");
+    const rbManager = new RollbackManager(tempDir);
+
+    const checkpoint = await cpManager.captureBeforeState("call-1", filePath);
+
+    writeFileSync(absPath, "modified-content", "utf8");
+    expect(readFileSync(absPath, "utf8")).toBe("modified-content");
+
+    rbManager.rollback(checkpoint);
+    expect(readFileSync(absPath, "utf8")).toBe("initial-content");
+  });
+
+  it("should delete newly created files on rollback", async () => {
+    const filePath = "new-file.txt";
+    const absPath = join(tempDir, filePath);
+
+    const cpManager = new CheckpointManager(tempDir, "session-123");
+    const rbManager = new RollbackManager(tempDir);
+
+    const checkpoint = await cpManager.captureBeforeState("call-1", filePath);
+
+    writeFileSync(absPath, "brand-new-file", "utf8");
+    expect(existsSync(absPath)).toBe(true);
+
+    rbManager.rollback(checkpoint);
+    expect(existsSync(absPath)).toBe(false);
+  });
+});

package/src/CheckpointManager.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { generateId, resolveSafePath } from "@wangjiehu/shared";
+import { FileBackup, Checkpoint } from "./types.js";
+
+export class CheckpointManager {
+  private checkpoints: Checkpoint[] = [];
+
+  constructor(
+    private cwd: string,
+    private sessionId: string,
+  ) {}
+
+  public async captureBeforeState(
+    toolCallId: string,
+    filePath: string,
+  ): Promise<Checkpoint> {
+    let originalContent: string | null = null;
+    try {
+      const safePath = resolveSafePath(this.cwd, filePath);
+      if (existsSync(safePath)) {
+        originalContent = readFileSync(safePath, "utf8");
+      }
+    } catch (e) {
+      // File does not exist yet or read failed
+    }
+
+    const backup: FileBackup = {
+      path: filePath,
+      originalContent,
+    };
+
+    const checkpoint: Checkpoint = {
+      id: generateId("cp"),
+      sessionId: this.sessionId,
+      timestamp: new Date().toISOString(),
+      toolCallId,
+      backups: [backup],
+    };
+
+    this.checkpoints.push(checkpoint);
+
+    const checkpointDir = join(
+      this.cwd,
+      ".orbit",
+      "checkpoints",
+      this.sessionId,
+      checkpoint.id,
+    );
+    mkdirSync(checkpointDir, { recursive: true });
+
+    if (originalContent !== null) {
+      writeFileSync(
+        join(checkpointDir, "backup_content.txt"),
+        originalContent,
+        "utf8",
+      );
+    }
+    writeFileSync(
+      join(checkpointDir, "meta.json"),
+      JSON.stringify({
+        id: checkpoint.id,
+        timestamp: checkpoint.timestamp,
+        toolCallId,
+        filePath,
+        exists: originalContent !== null,
+      }),
+      "utf8",
+    );
+
+    return checkpoint;
+  }
+
+  public getCheckpoints(): Checkpoint[] {
+    return this.checkpoints;
+  }
+}

package/src/RollbackManager.ts

@@ -0,0 +1,36 @@
+import { existsSync, writeFileSync, unlinkSync } from "fs";
+import { resolveSafePath } from "@wangjiehu/shared";
+import { Checkpoint } from "./types.js";
+
+export class RollbackManager {
+  constructor(private cwd: string) {}
+
+  public rollback(checkpoint: Checkpoint): {
+    success: boolean;
+    error?: string;
+    restored: string[];
+  } {
+    const restored: string[] = [];
+
+    for (const backup of checkpoint.backups) {
+      const safePath = resolveSafePath(this.cwd, backup.path);
+
+      if (backup.originalContent === null) {
+        // File did not exist before the tool execution, so delete it on rollback
+        if (existsSync(safePath)) {
+          unlinkSync(safePath);
+          restored.push(backup.path);
+        }
+      } else {
+        // Restore previous content
+        writeFileSync(safePath, backup.originalContent, "utf8");
+        restored.push(backup.path);
+      }
+    }
+
+    return {
+      success: true,
+      restored,
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./CheckpointManager.js";
+export * from "./RollbackManager.js";

package/src/types.ts

@@ -0,0 +1,13 @@
+export interface FileBackup {
+  path: string;
+  originalContent: string | null; // null if the file did not exist before
+  originalHash?: string;
+}
+
+export interface Checkpoint {
+  id: string;
+  sessionId: string;
+  timestamp: string;
+  toolCallId: string;
+  backups: FileBackup[];
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}