@pixelbyte-software/pixcode 1.35.0 → 1.35.1

package/server/modules/orchestration/workspace/types.ts

@@ -1,52 +1,52 @@
-import type { ExecFileOptions } from 'node:child_process';
-
-export type WorkspaceKind = 'host' | 'worktree' | 'docker';
-
-export interface ExecResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-export interface WorkspaceHandle {
-  id: string;
-  kind: WorkspaceKind;
-  path: string;
-  baseRef: string;
-  branchName?: string;
-  metadata: Record<string, unknown>;
-  exec(command: string, args?: string[], options?: ExecFileOptions): Promise<ExecResult>;
-  readFile(relativePath: string): Promise<string>;
-  writeFile(relativePath: string, content: string): Promise<void>;
-  diff(): Promise<string>;
-  destroy(): Promise<void>;
-}
-
-export interface WorkspaceRequest {
-  taskId: string;
-  projectPath: string;
-  kind?: WorkspaceKind;
-  baseRef?: string;
-  keepAfterCompletion?: boolean;
-  metadata?: Record<string, unknown>;
-}
-
-export interface WorkspaceMetadata {
-  id: string;
-  kind: WorkspaceKind;
-  path: string;
-  baseRef: string;
-  branchName?: string;
-  keepAfterCompletion?: boolean;
-}
-
-export class WorkspaceError extends Error {
-  constructor(
-    public readonly code: string,
-    message: string,
-    public readonly details: Record<string, unknown> = {},
-  ) {
-    super(message);
-    this.name = 'WorkspaceError';
-  }
-}
+import type { ExecFileOptions } from 'node:child_process';
+
+export type WorkspaceKind = 'host' | 'worktree' | 'docker';
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface WorkspaceHandle {
+  id: string;
+  kind: WorkspaceKind;
+  path: string;
+  baseRef: string;
+  branchName?: string;
+  metadata: Record<string, unknown>;
+  exec(command: string, args?: string[], options?: ExecFileOptions): Promise<ExecResult>;
+  readFile(relativePath: string): Promise<string>;
+  writeFile(relativePath: string, content: string): Promise<void>;
+  diff(): Promise<string>;
+  destroy(): Promise<void>;
+}
+
+export interface WorkspaceRequest {
+  taskId: string;
+  projectPath: string;
+  kind?: WorkspaceKind;
+  baseRef?: string;
+  keepAfterCompletion?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export interface WorkspaceMetadata {
+  id: string;
+  kind: WorkspaceKind;
+  path: string;
+  baseRef: string;
+  branchName?: string;
+  keepAfterCompletion?: boolean;
+}
+
+export class WorkspaceError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+    public readonly details: Record<string, unknown> = {},
+  ) {
+    super(message);
+    this.name = 'WorkspaceError';
+  }
+}

package/server/modules/orchestration/workspace/workspace-manager.ts

@@ -1,97 +1,97 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { DockerWorkspace } from '@/modules/orchestration/workspace/docker-workspace.js';
-import { safeJoin } from '@/modules/orchestration/workspace/path-safety.js';
-import type {
-  ExecResult,
-  WorkspaceHandle,
-  WorkspaceKind,
-  WorkspaceRequest,
-} from '@/modules/orchestration/workspace/types.js';
-import { WorktreeWorkspace } from '@/modules/orchestration/workspace/worktree-workspace.js';
-
-class HostWorkspace implements WorkspaceHandle {
-  readonly kind = 'host' as const;
-  readonly id: string;
-  readonly path: string;
-  readonly baseRef: string;
-  readonly metadata: Record<string, unknown>;
-
-  constructor(request: WorkspaceRequest) {
-    this.id = `host_${request.taskId}`;
-    this.path = request.projectPath;
-    this.baseRef = request.baseRef ?? 'HEAD';
-    this.metadata = { ...request.metadata, keepAfterCompletion: true };
-  }
-
-  async exec(command: string, args: string[] = []): Promise<ExecResult> {
-    const { execFile } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const execFileAsync = promisify(execFile);
-    try {
-      const { stdout, stderr } = await execFileAsync(command, args, {
-        cwd: this.path,
-        maxBuffer: 20 * 1024 * 1024,
-      });
-      return { stdout: String(stdout), stderr: String(stderr), exitCode: 0 };
-    } catch (error) {
-      const err = error as Error & { stdout?: string; stderr?: string; code?: number };
-      return {
-        stdout: String(err.stdout ?? ''),
-        stderr: String(err.stderr ?? err.message),
-        exitCode: typeof err.code === 'number' ? err.code : 1,
-      };
-    }
-  }
-
-  async readFile(relativePath: string): Promise<string> {
-    return fs.promises.readFile(safeJoin(this.path, relativePath), 'utf8');
-  }
-
-  async writeFile(relativePath: string, content: string): Promise<void> {
-    const target = safeJoin(this.path, relativePath);
-    await fs.promises.mkdir(path.dirname(target), { recursive: true });
-    await fs.promises.writeFile(target, content, 'utf8');
-  }
-
-  async diff(): Promise<string> {
-    const result = await this.exec('git', ['diff', `${this.baseRef}...HEAD`]);
-    return result.exitCode === 0 ? result.stdout : result.stderr || result.stdout;
-  }
-
-  destroy(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-function readKind(value: unknown): WorkspaceKind {
-  return value === 'host' || value === 'docker' || value === 'worktree' ? value : 'worktree';
-}
-
-class WorkspaceManager {
-  async create(request: WorkspaceRequest): Promise<WorkspaceHandle> {
-    const kind = readKind(request.kind);
-    if (kind === 'host') {
-      return new HostWorkspace(request);
-    }
-    if (kind === 'docker') {
-      return new DockerWorkspace(request);
-    }
-    return WorktreeWorkspace.create(request);
-  }
-
-  recover(request: WorkspaceRequest): WorkspaceHandle {
-    return new HostWorkspace({
-      ...request,
-      kind: 'host',
-      metadata: {
-        ...request.metadata,
-        recovered: true,
-      },
-    });
-  }
-}
-
-export const workspaceManager = new WorkspaceManager();
-export type { WorkspaceManager };
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { DockerWorkspace } from '@/modules/orchestration/workspace/docker-workspace.js';
+import { safeJoin } from '@/modules/orchestration/workspace/path-safety.js';
+import type {
+  ExecResult,
+  WorkspaceHandle,
+  WorkspaceKind,
+  WorkspaceRequest,
+} from '@/modules/orchestration/workspace/types.js';
+import { WorktreeWorkspace } from '@/modules/orchestration/workspace/worktree-workspace.js';
+
+class HostWorkspace implements WorkspaceHandle {
+  readonly kind = 'host' as const;
+  readonly id: string;
+  readonly path: string;
+  readonly baseRef: string;
+  readonly metadata: Record<string, unknown>;
+
+  constructor(request: WorkspaceRequest) {
+    this.id = `host_${request.taskId}`;
+    this.path = request.projectPath;
+    this.baseRef = request.baseRef ?? 'HEAD';
+    this.metadata = { ...request.metadata, keepAfterCompletion: true };
+  }
+
+  async exec(command: string, args: string[] = []): Promise<ExecResult> {
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileAsync = promisify(execFile);
+    try {
+      const { stdout, stderr } = await execFileAsync(command, args, {
+        cwd: this.path,
+        maxBuffer: 20 * 1024 * 1024,
+      });
+      return { stdout: String(stdout), stderr: String(stderr), exitCode: 0 };
+    } catch (error) {
+      const err = error as Error & { stdout?: string; stderr?: string; code?: number };
+      return {
+        stdout: String(err.stdout ?? ''),
+        stderr: String(err.stderr ?? err.message),
+        exitCode: typeof err.code === 'number' ? err.code : 1,
+      };
+    }
+  }
+
+  async readFile(relativePath: string): Promise<string> {
+    return fs.promises.readFile(safeJoin(this.path, relativePath), 'utf8');
+  }
+
+  async writeFile(relativePath: string, content: string): Promise<void> {
+    const target = safeJoin(this.path, relativePath);
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
+    await fs.promises.writeFile(target, content, 'utf8');
+  }
+
+  async diff(): Promise<string> {
+    const result = await this.exec('git', ['diff', `${this.baseRef}...HEAD`]);
+    return result.exitCode === 0 ? result.stdout : result.stderr || result.stdout;
+  }
+
+  destroy(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+function readKind(value: unknown): WorkspaceKind {
+  return value === 'host' || value === 'docker' || value === 'worktree' ? value : 'worktree';
+}
+
+class WorkspaceManager {
+  async create(request: WorkspaceRequest): Promise<WorkspaceHandle> {
+    const kind = readKind(request.kind);
+    if (kind === 'host') {
+      return new HostWorkspace(request);
+    }
+    if (kind === 'docker') {
+      return new DockerWorkspace(request);
+    }
+    return WorktreeWorkspace.create(request);
+  }
+
+  recover(request: WorkspaceRequest): WorkspaceHandle {
+    return new HostWorkspace({
+      ...request,
+      kind: 'host',
+      metadata: {
+        ...request.metadata,
+        recovered: true,
+      },
+    });
+  }
+}
+
+export const workspaceManager = new WorkspaceManager();
+export type { WorkspaceManager };

package/server/modules/orchestration/workspace/worktree-workspace.ts

@@ -1,125 +1,125 @@
-import { execFile } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { promisify } from 'node:util';
-
-import { assertSafeId, safeJoin, safeWorkspacePath } from '@/modules/orchestration/workspace/path-safety.js';
-import type {
-  ExecResult,
-  WorkspaceHandle,
-  WorkspaceRequest,
-} from '@/modules/orchestration/workspace/types.js';
-import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
-
-const execFileAsync = promisify(execFile);
-
-async function run(
-  command: string,
-  args: string[],
-  cwd: string,
-): Promise<ExecResult> {
-  try {
-    const { stdout, stderr } = await execFileAsync(command, args, {
-      cwd,
-      maxBuffer: 20 * 1024 * 1024,
-    });
-    return {
-      stdout: String(stdout),
-      stderr: String(stderr),
-      exitCode: 0,
-    };
-  } catch (error) {
-    const err = error as Error & {
-      stdout?: string | Buffer;
-      stderr?: string | Buffer;
-      code?: number;
-    };
-    return {
-      stdout: String(err.stdout ?? ''),
-      stderr: String(err.stderr ?? err.message),
-      exitCode: typeof err.code === 'number' ? err.code : 1,
-    };
-  }
-}
-
-export class WorktreeWorkspace implements WorkspaceHandle {
-  readonly kind = 'worktree' as const;
-  readonly id: string;
-  readonly path: string;
-  readonly baseRef: string;
-  readonly branchName: string;
-  readonly metadata: Record<string, unknown>;
-  private readonly projectPath: string;
-
-  private constructor(request: WorkspaceRequest, workspaceId: string, branchName: string) {
-    this.id = workspaceId;
-    this.path = safeWorkspacePath(workspaceId);
-    this.baseRef = request.baseRef ?? 'HEAD';
-    this.branchName = branchName;
-    this.projectPath = request.projectPath;
-    this.metadata = {
-      ...request.metadata,
-      keepAfterCompletion: request.keepAfterCompletion === true,
-    };
-  }
-
-  static async create(request: WorkspaceRequest): Promise<WorktreeWorkspace> {
-    assertSafeId(request.taskId, 'task id');
-    const workspaceId = `ws_${request.taskId}`;
-    const branchName = `pixcode/task_${request.taskId}`;
-    const workspace = new WorktreeWorkspace(request, workspaceId, branchName);
-
-    const existingBranch = await run('git', ['rev-parse', '--verify', branchName], request.projectPath);
-    if (existingBranch.exitCode === 0) {
-      throw new WorkspaceError('WORKSPACE_EXISTS', `Workspace branch already exists: ${branchName}`, {
-        branchName,
-      });
-    }
-
-    const result = await run(
-      'git',
-      ['worktree', 'add', workspace.path, '-b', branchName, workspace.baseRef],
-      request.projectPath,
-    );
-    if (result.exitCode !== 0) {
-      throw new WorkspaceError('WORKSPACE_CREATE_FAILED', result.stderr || result.stdout, {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        baseRef: workspace.baseRef,
-      });
-    }
-
-    return workspace;
-  }
-
-  exec(command: string, args: string[] = []): Promise<ExecResult> {
-    return run(command, args, this.path);
-  }
-
-  async readFile(relativePath: string): Promise<string> {
-    return fs.readFile(safeJoin(this.path, relativePath), 'utf8');
-  }
-
-  async writeFile(relativePath: string, content: string): Promise<void> {
-    const target = safeJoin(this.path, relativePath);
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await fs.writeFile(target, content, 'utf8');
-  }
-
-  async diff(): Promise<string> {
-    const result = await run('git', ['diff', `${this.baseRef}...HEAD`], this.path);
-    if (result.exitCode !== 0) {
-      return result.stderr || result.stdout;
-    }
-    return result.stdout;
-  }
-
-  async destroy(): Promise<void> {
-    const result = await run('git', ['worktree', 'remove', '--force', this.path], this.projectPath);
-    if (result.exitCode !== 0) {
-      throw new WorkspaceError('WORKSPACE_DESTROY_FAILED', result.stderr || result.stdout, {
-        workspacePath: this.path,
-      });
-    }
-  }
-}
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { assertSafeId, safeJoin, safeWorkspacePath } from '@/modules/orchestration/workspace/path-safety.js';
+import type {
+  ExecResult,
+  WorkspaceHandle,
+  WorkspaceRequest,
+} from '@/modules/orchestration/workspace/types.js';
+import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
+
+const execFileAsync = promisify(execFile);
+
+async function run(
+  command: string,
+  args: string[],
+  cwd: string,
+): Promise<ExecResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, {
+      cwd,
+      maxBuffer: 20 * 1024 * 1024,
+    });
+    return {
+      stdout: String(stdout),
+      stderr: String(stderr),
+      exitCode: 0,
+    };
+  } catch (error) {
+    const err = error as Error & {
+      stdout?: string | Buffer;
+      stderr?: string | Buffer;
+      code?: number;
+    };
+    return {
+      stdout: String(err.stdout ?? ''),
+      stderr: String(err.stderr ?? err.message),
+      exitCode: typeof err.code === 'number' ? err.code : 1,
+    };
+  }
+}
+
+export class WorktreeWorkspace implements WorkspaceHandle {
+  readonly kind = 'worktree' as const;
+  readonly id: string;
+  readonly path: string;
+  readonly baseRef: string;
+  readonly branchName: string;
+  readonly metadata: Record<string, unknown>;
+  private readonly projectPath: string;
+
+  private constructor(request: WorkspaceRequest, workspaceId: string, branchName: string) {
+    this.id = workspaceId;
+    this.path = safeWorkspacePath(workspaceId);
+    this.baseRef = request.baseRef ?? 'HEAD';
+    this.branchName = branchName;
+    this.projectPath = request.projectPath;
+    this.metadata = {
+      ...request.metadata,
+      keepAfterCompletion: request.keepAfterCompletion === true,
+    };
+  }
+
+  static async create(request: WorkspaceRequest): Promise<WorktreeWorkspace> {
+    assertSafeId(request.taskId, 'task id');
+    const workspaceId = `ws_${request.taskId}`;
+    const branchName = `pixcode/task_${request.taskId}`;
+    const workspace = new WorktreeWorkspace(request, workspaceId, branchName);
+
+    const existingBranch = await run('git', ['rev-parse', '--verify', branchName], request.projectPath);
+    if (existingBranch.exitCode === 0) {
+      throw new WorkspaceError('WORKSPACE_EXISTS', `Workspace branch already exists: ${branchName}`, {
+        branchName,
+      });
+    }
+
+    const result = await run(
+      'git',
+      ['worktree', 'add', workspace.path, '-b', branchName, workspace.baseRef],
+      request.projectPath,
+    );
+    if (result.exitCode !== 0) {
+      throw new WorkspaceError('WORKSPACE_CREATE_FAILED', result.stderr || result.stdout, {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        baseRef: workspace.baseRef,
+      });
+    }
+
+    return workspace;
+  }
+
+  exec(command: string, args: string[] = []): Promise<ExecResult> {
+    return run(command, args, this.path);
+  }
+
+  async readFile(relativePath: string): Promise<string> {
+    return fs.readFile(safeJoin(this.path, relativePath), 'utf8');
+  }
+
+  async writeFile(relativePath: string, content: string): Promise<void> {
+    const target = safeJoin(this.path, relativePath);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, content, 'utf8');
+  }
+
+  async diff(): Promise<string> {
+    const result = await run('git', ['diff', `${this.baseRef}...HEAD`], this.path);
+    if (result.exitCode !== 0) {
+      return result.stderr || result.stdout;
+    }
+    return result.stdout;
+  }
+
+  async destroy(): Promise<void> {
+    const result = await run('git', ['worktree', 'remove', '--force', this.path], this.projectPath);
+    if (result.exitCode !== 0) {
+      throw new WorkspaceError('WORKSPACE_DESTROY_FAILED', result.stderr || result.stdout, {
+        workspacePath: this.path,
+      });
+    }
+  }
+}

package/server/modules/providers/index.ts

@@ -1,2 +1,2 @@
-export { providerRegistry } from './provider.registry.js';
-export { CodexSessionsProvider } from './list/codex/codex-sessions.provider.js';
+export { providerRegistry } from './provider.registry.js';
+export { CodexSessionsProvider } from './list/codex/codex-sessions.provider.js';