oxe-cc 1.2.1 → 1.4.0

package/packages/runtime/src/workspace/strategies/ephemeral-container.ts

@@ -1,121 +1,126 @@
-import { execFileSync, spawnSync } from 'child_process';
-import crypto from 'crypto';
-import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
-import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
-import { GitWorktreeManager } from './git-worktree';
-
-export interface ContainerOptions {
-  image: string;
-  mountPath: string;
-  extraEnv?: Record<string, string>;
-  /** Gracefully fall back to git_worktree if Docker is unavailable */
-  fallback?: boolean;
-}
-
-function isDockerAvailable(): boolean {
-  const result = spawnSync('docker', ['version', '--format', '{{.Server.Version}}'], {
-    encoding: 'utf8',
-    timeout: 5000,
-  });
-  return result.status === 0;
-}
-
-export class EphemeralContainerManager implements WorkspaceManager {
-  private readonly fallbackManager: GitWorktreeManager;
-  private containerIds = new Map<string, string>();
-  private useFallback = false;
-
-  constructor(
-    private readonly projectRoot: string,
-    private readonly opts: ContainerOptions = { image: 'node:20-alpine', mountPath: '/workspace', fallback: true }
-  ) {
-    this.fallbackManager = new GitWorktreeManager(projectRoot);
-    if (!isDockerAvailable()) {
-      if (opts.fallback !== false) {
-        this.useFallback = true;
-      } else {
-        throw new Error('Docker is not available and fallback is disabled');
-      }
-    }
-  }
-
-  get usingFallback(): boolean { return this.useFallback; }
-
-  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
-    if (this.useFallback) return this.fallbackManager.allocate(req);
-
-    const wsId = `ws-container-${req.work_item_id}-a${req.attempt_number}`;
-    const envArgs = Object.entries(this.opts.extraEnv ?? {}).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
-
-    const result = spawnSync('docker', [
-      'run', '-d',
-      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
-      '-w', this.opts.mountPath,
-      ...envArgs,
-      this.opts.image,
-      'sleep', '3600',
-    ], { encoding: 'utf8' });
-
-    if (result.status !== 0) {
-      if (this.opts.fallback !== false) {
-        this.useFallback = true;
-        return this.fallbackManager.allocate(req);
-      }
-      throw new Error(`docker run failed: ${result.stderr}`);
-    }
-
-    const containerId = result.stdout.trim().slice(0, 12);
-    this.containerIds.set(wsId, containerId);
-
-    return {
-      workspace_id: wsId,
-      strategy: 'ephemeral_container',
-      branch: null,
-      base_commit: null,
-      root_path: `docker:${containerId}:${this.opts.mountPath}`,
-      ttl_minutes: 60,
-    };
-  }
-
-  async snapshot(id: string): Promise<SnapshotRef> {
-    if (this.useFallback) return this.fallbackManager.snapshot(id);
-    const containerId = this.containerIds.get(id);
-    if (!containerId) throw new Error(`Container for workspace ${id} not found`);
-
-    const tag = `oxe-snap-${crypto.randomBytes(4).toString('hex')}`;
-    execFileSync('docker', ['commit', containerId, tag]);
-
-    return {
-      snapshot_id: tag,
-      workspace_id: id,
-      commit: tag,
-      created_at: new Date().toISOString(),
-    };
-  }
-
-  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
-    if (this.useFallback) return this.fallbackManager.reset(id, snapRef);
-    const containerId = this.containerIds.get(id);
-    if (!containerId) return;
-    // Stop current container and start from snapshot
-    spawnSync('docker', ['stop', containerId]);
-    spawnSync('docker', ['rm', containerId]);
-    const result = spawnSync('docker', [
-      'run', '-d',
-      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
-      snapRef.commit,
-      'sleep', '3600',
-    ], { encoding: 'utf8' });
-    const newId = result.stdout.trim().slice(0, 12);
-    this.containerIds.set(id, newId);
-  }
-
-  async dispose(id: string): Promise<void> {
-    if (this.useFallback) return this.fallbackManager.dispose(id);
-    const containerId = this.containerIds.get(id);
-    if (!containerId) return;
-    spawnSync('docker', ['stop', containerId], { encoding: 'utf8' });
-    spawnSync('docker', ['rm', containerId], { encoding: 'utf8' });
-    this.containerIds.delete(id);
-  }
-}
+import { execFileSync, spawnSync } from 'child_process';
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+import { GitWorktreeManager } from './git-worktree';
+
+export interface ContainerOptions {
+  image: string;
+  mountPath: string;
+  extraEnv?: Record<string, string>;
+  /** Gracefully fall back to git_worktree if Docker is unavailable */
+  fallback?: boolean;
+}
+
+function isDockerAvailable(): boolean {
+  const result = spawnSync('docker', ['version', '--format', '{{.Server.Version}}'], {
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  return result.status === 0;
+}
+
+export class EphemeralContainerManager implements WorkspaceManager {
+  private readonly fallbackManager: GitWorktreeManager;
+  private containerIds = new Map<string, string>();
+  private useFallback = false;
+
+  constructor(
+    private readonly projectRoot: string,
+    private readonly opts: ContainerOptions = { image: 'node:20-alpine', mountPath: '/workspace', fallback: true }
+  ) {
+    this.fallbackManager = new GitWorktreeManager(projectRoot);
+    if (!isDockerAvailable()) {
+      if (opts.fallback !== false) {
+        this.useFallback = true;
+      } else {
+        throw new Error('Docker is not available and fallback is disabled');
+      }
+    }
+  }
+
+  get isolation_level(): 'shared' | 'isolated' {
+    return this.useFallback ? this.fallbackManager.isolation_level : 'isolated';
+  }
+
+  get usingFallback(): boolean { return this.useFallback; }
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    if (this.useFallback) return this.fallbackManager.allocate(req);
+
+    const wsId = `ws-container-${req.work_item_id}-a${req.attempt_number}`;
+    const envArgs = Object.entries(this.opts.extraEnv ?? {}).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
+
+    const result = spawnSync('docker', [
+      'run', '-d',
+      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
+      '-w', this.opts.mountPath,
+      ...envArgs,
+      this.opts.image,
+      'sleep', '3600',
+    ], { encoding: 'utf8' });
+
+    if (result.status !== 0) {
+      if (this.opts.fallback !== false) {
+        this.useFallback = true;
+        return this.fallbackManager.allocate(req);
+      }
+      throw new Error(`docker run failed: ${result.stderr}`);
+    }
+
+    const containerId = result.stdout.trim().slice(0, 12);
+    this.containerIds.set(wsId, containerId);
+
+    return {
+      workspace_id: wsId,
+      strategy: 'ephemeral_container',
+      isolation_level: this.isolation_level,
+      branch: null,
+      base_commit: null,
+      root_path: `docker:${containerId}:${this.opts.mountPath}`,
+      ttl_minutes: 60,
+    };
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    if (this.useFallback) return this.fallbackManager.snapshot(id);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) throw new Error(`Container for workspace ${id} not found`);
+
+    const tag = `oxe-snap-${crypto.randomBytes(4).toString('hex')}`;
+    execFileSync('docker', ['commit', containerId, tag]);
+
+    return {
+      snapshot_id: tag,
+      workspace_id: id,
+      commit: tag,
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
+    if (this.useFallback) return this.fallbackManager.reset(id, snapRef);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) return;
+    // Stop current container and start from snapshot
+    spawnSync('docker', ['stop', containerId]);
+    spawnSync('docker', ['rm', containerId]);
+    const result = spawnSync('docker', [
+      'run', '-d',
+      '-v', `${this.projectRoot}:${this.opts.mountPath}`,
+      snapRef.commit,
+      'sleep', '3600',
+    ], { encoding: 'utf8' });
+    const newId = result.stdout.trim().slice(0, 12);
+    this.containerIds.set(id, newId);
+  }
+
+  async dispose(id: string): Promise<void> {
+    if (this.useFallback) return this.fallbackManager.dispose(id);
+    const containerId = this.containerIds.get(id);
+    if (!containerId) return;
+    spawnSync('docker', ['stop', containerId], { encoding: 'utf8' });
+    spawnSync('docker', ['rm', containerId], { encoding: 'utf8' });
+    this.containerIds.delete(id);
+  }
+}

package/packages/runtime/src/workspace/strategies/git-worktree.ts

@@ -1,77 +1,79 @@
-import { execFileSync } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto';
-import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
-import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
-
-export class GitWorktreeManager implements WorkspaceManager {
-  private leases = new Map<string, WorkspaceLease>();
-
-  constructor(private readonly projectRoot: string) {}
-
-  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
-    const wsId = `ws-${req.work_item_id}-a${req.attempt_number}`;
-    const branch = `oxe/${req.work_item_id}-attempt${req.attempt_number}`;
-    const worktreePath = path.join(this.projectRoot, '.oxe', 'workspaces', wsId);
-
-    const baseCommit = this.git(['rev-parse', 'HEAD']).trim();
-
-    fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
-
-    // Create worktree on a new branch starting from HEAD
-    this.git(['worktree', 'add', worktreePath, '-b', branch]);
-
-    const lease: WorkspaceLease = {
-      workspace_id: wsId,
-      strategy: 'git_worktree',
-      branch,
-      base_commit: baseCommit,
-      root_path: worktreePath,
-      ttl_minutes: 45,
-    };
-    this.leases.set(wsId, lease);
-    return lease;
-  }
-
-  async snapshot(id: string): Promise<SnapshotRef> {
-    const lease = this.leases.get(id);
-    if (!lease || !lease.root_path) throw new Error(`Workspace ${id} not found`);
-    const commit = this.git(['rev-parse', 'HEAD'], lease.root_path).trim();
-    return {
-      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
-      workspace_id: id,
-      commit,
-      created_at: new Date().toISOString(),
-    };
-  }
-
-  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
-    const lease = this.leases.get(id);
-    if (!lease) return;
-    this.git(['reset', '--hard', snapRef.commit], lease.root_path);
-  }
-
-  async dispose(id: string): Promise<void> {
-    const lease = this.leases.get(id);
-    if (!lease) return;
-    try {
-      this.git(['worktree', 'remove', lease.root_path, '--force']);
-    } catch {
-      // worktree may already be gone
-    }
-    try {
-      if (lease.branch) this.git(['branch', '-D', lease.branch]);
-    } catch {
-      // branch may already be deleted
-    }
-    this.leases.delete(id);
-  }
-
-  private git(args: string[], cwd?: string): string {
-    return execFileSync('git', args, {
-      cwd: cwd ?? this.projectRoot,
-      encoding: 'utf8',
-    });
-  }
-}
+import { execFileSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+
+export class GitWorktreeManager implements WorkspaceManager {
+  readonly isolation_level = 'isolated' as const;
+  private leases = new Map<string, WorkspaceLease>();
+
+  constructor(private readonly projectRoot: string) {}
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    const wsId = `ws-${req.work_item_id}-a${req.attempt_number}`;
+    const branch = `oxe/${req.work_item_id}-attempt${req.attempt_number}`;
+    const worktreePath = path.join(this.projectRoot, '.oxe', 'workspaces', wsId);
+
+    const baseCommit = this.git(['rev-parse', 'HEAD']).trim();
+
+    fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+
+    // Create worktree on a new branch starting from HEAD
+    this.git(['worktree', 'add', worktreePath, '-b', branch]);
+
+    const lease: WorkspaceLease = {
+      workspace_id: wsId,
+      strategy: 'git_worktree',
+      isolation_level: this.isolation_level,
+      branch,
+      base_commit: baseCommit,
+      root_path: worktreePath,
+      ttl_minutes: 45,
+    };
+    this.leases.set(wsId, lease);
+    return lease;
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    const lease = this.leases.get(id);
+    if (!lease || !lease.root_path) throw new Error(`Workspace ${id} not found`);
+    const commit = this.git(['rev-parse', 'HEAD'], lease.root_path).trim();
+    return {
+      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
+      workspace_id: id,
+      commit,
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(id: string, snapRef: SnapshotRef): Promise<void> {
+    const lease = this.leases.get(id);
+    if (!lease) return;
+    this.git(['reset', '--hard', snapRef.commit], lease.root_path);
+  }
+
+  async dispose(id: string): Promise<void> {
+    const lease = this.leases.get(id);
+    if (!lease) return;
+    try {
+      this.git(['worktree', 'remove', lease.root_path, '--force']);
+    } catch {
+      // worktree may already be gone
+    }
+    try {
+      if (lease.branch) this.git(['branch', '-D', lease.branch]);
+    } catch {
+      // branch may already be deleted
+    }
+    this.leases.delete(id);
+  }
+
+  private git(args: string[], cwd?: string): string {
+    return execFileSync('git', args, {
+      cwd: cwd ?? this.projectRoot,
+      encoding: 'utf8',
+    });
+  }
+}

package/packages/runtime/src/workspace/strategies/inplace.ts

@@ -1,35 +1,38 @@
-import crypto from 'crypto';
-import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
-import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
-
-export class InplaceWorkspaceManager implements WorkspaceManager {
-  constructor(private readonly projectRoot: string) {}
-
-  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
-    return {
-      workspace_id: `ws-inplace-${req.work_item_id}-a${req.attempt_number}`,
-      strategy: 'inplace',
-      branch: null,
-      base_commit: null,
-      root_path: this.projectRoot,
-      ttl_minutes: 60,
-    };
-  }
-
-  async snapshot(id: string): Promise<SnapshotRef> {
-    return {
-      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
-      workspace_id: id,
-      commit: 'HEAD',
-      created_at: new Date().toISOString(),
-    };
-  }
-
-  async reset(_id: string, _snapRef: SnapshotRef): Promise<void> {
-    // inplace: no filesystem isolation — reset is a no-op
-  }
-
-  async dispose(_id: string): Promise<void> {
-    // inplace: nothing to tear down
-  }
-}
+import crypto from 'crypto';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../../models/workspace';
+
+export class InplaceWorkspaceManager implements WorkspaceManager {
+  readonly isolation_level = 'shared' as const;
+
+  constructor(private readonly projectRoot: string) {}
+
+  async allocate(req: WorkspaceRequest): Promise<WorkspaceLease> {
+    return {
+      workspace_id: `ws-inplace-${req.work_item_id}-a${req.attempt_number}`,
+      strategy: 'inplace',
+      isolation_level: this.isolation_level,
+      branch: null,
+      base_commit: null,
+      root_path: this.projectRoot,
+      ttl_minutes: 60,
+    };
+  }
+
+  async snapshot(id: string): Promise<SnapshotRef> {
+    return {
+      snapshot_id: `snap-${crypto.randomBytes(4).toString('hex')}`,
+      workspace_id: id,
+      commit: 'HEAD',
+      created_at: new Date().toISOString(),
+    };
+  }
+
+  async reset(_id: string, _snapRef: SnapshotRef): Promise<void> {
+    // inplace: no filesystem isolation — reset is a no-op
+  }
+
+  async dispose(_id: string): Promise<void> {
+    // inplace: nothing to tear down
+  }
+}

package/packages/runtime/src/workspace/workspace-manager.ts

@@ -1,15 +1,16 @@
-import type { WorkspaceLease, SnapshotRef, WorkspaceStrategy } from '../models/workspace';
-
-export interface WorkspaceRequest {
-  work_item_id: string;
-  attempt_number: number;
-  strategy: WorkspaceStrategy;
-  mutation_scope: string[];
-}
-
-export interface WorkspaceManager {
-  allocate(req: WorkspaceRequest): Promise<WorkspaceLease>;
-  snapshot(id: string): Promise<SnapshotRef>;
-  reset(id: string, snapRef: SnapshotRef): Promise<void>;
-  dispose(id: string): Promise<void>;
-}
+import type { WorkspaceLease, SnapshotRef, WorkspaceStrategy, WorkspaceIsolationLevel } from '../models/workspace';
+
+export interface WorkspaceRequest {
+  work_item_id: string;
+  attempt_number: number;
+  strategy: WorkspaceStrategy;
+  mutation_scope: string[];
+}
+
+export interface WorkspaceManager {
+  readonly isolation_level: WorkspaceIsolationLevel;
+  allocate(req: WorkspaceRequest): Promise<WorkspaceLease>;
+  snapshot(id: string): Promise<SnapshotRef>;
+  reset(id: string, snapRef: SnapshotRef): Promise<void>;
+  dispose(id: string): Promise<void>;
+}

package/packages/runtime/tsconfig.json

@@ -1,17 +1,17 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "declarationMap": false,
-    "sourceMap": false,
-    "outDir": "../../lib/runtime",
-    "rootDir": "src",
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["tests/**", "node_modules/**", "dist-tests/**"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": false,
+    "outDir": "../../lib/runtime",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["tests/**", "node_modules/**", "dist-tests/**"]
+}

package/vscode-extension/.vscodeignore

@@ -1,7 +1,7 @@
-.vscode/**
-.git/**
-.gitignore
-node_modules/**
-**/*.map
-**/*.test.js
-tests/**
+.vscode/**
+.git/**
+.gitignore
+node_modules/**
+**/*.map
+**/*.test.js
+tests/**

package/vscode-extension/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OXE contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.