@pixelbyte-software/pixcode 1.54.10 → 1.55.0

package/server/modules/orchestration/workflows/workspace-target.ts

@@ -1,122 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export type WorkspaceTargetKind = 'selected_project' | 'pixcode_app' | 'custom';
-
-export type ResolvedWorkspaceTarget = {
-  kind: WorkspaceTargetKind;
-  label: string;
-  projectPath: string;
-  selectedProjectPath?: string;
-  selectedProjectName?: string;
-  appRoot: string;
-};
-
-const pixcodePackageName = '@pixelbyte-software/pixcode';
-
-function readRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
-}
-
-function readString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-
-function readTargetKind(value: unknown): WorkspaceTargetKind | undefined {
-  return value === 'selected_project' || value === 'pixcode_app' || value === 'custom'
-    ? value
-    : undefined;
-}
-
-export function findPixcodeAppRoot(): string {
-  let currentDir = dirname(fileURLToPath(import.meta.url));
-
-  for (let depth = 0; depth < 10; depth += 1) {
-    try {
-      const packagePath = resolve(currentDir, 'package.json');
-      const pkg = JSON.parse(readFileSync(packagePath, 'utf8')) as { name?: string };
-      if (pkg.name === pixcodePackageName) {
-        return currentDir;
-      }
-    } catch {
-      // Walk upward until the Pixcode package root is found.
-    }
-
-    const parent = dirname(currentDir);
-    if (parent === currentDir) break;
-    currentDir = parent;
-  }
-
-  return process.cwd();
-}
-
-export function resolveWorkflowWorkspace(metadata?: Record<string, unknown>): ResolvedWorkspaceTarget {
-  const target = readRecord(metadata?.workspaceTarget);
-  const appRoot = findPixcodeAppRoot();
-  const selectedProjectPath = readString(metadata?.selectedProjectPath) ?? readString(metadata?.projectPath);
-  const selectedProjectName = readString(metadata?.projectName) ?? readString(metadata?.projectId);
-  const kind = readTargetKind(target?.kind) ?? 'selected_project';
-  const customPath = readString(target?.projectPath);
-
-  if (kind === 'pixcode_app') {
-    return {
-      kind,
-      label: 'Pixcode app',
-      projectPath: appRoot,
-      selectedProjectPath,
-      selectedProjectName,
-      appRoot,
-    };
-  }
-
-  if (kind === 'custom') {
-    return {
-      kind,
-      label: readString(target?.label) ?? 'Custom workspace',
-      projectPath: customPath ?? selectedProjectPath ?? appRoot,
-      selectedProjectPath,
-      selectedProjectName,
-      appRoot,
-    };
-  }
-
-  return {
-    kind: 'selected_project',
-    label: selectedProjectName ?? 'Selected project',
-    projectPath: selectedProjectPath ?? appRoot,
-    selectedProjectPath,
-    selectedProjectName,
-    appRoot,
-  };
-}
-
-export function workspaceTargetMetadata(target: ResolvedWorkspaceTarget): Record<string, unknown> {
-  return {
-    kind: target.kind,
-    label: target.label,
-    projectPath: target.projectPath,
-    selectedProjectPath: target.selectedProjectPath,
-    selectedProjectName: target.selectedProjectName,
-    appRoot: target.appRoot,
-  };
-}
-
-export function workspaceContextPrompt(target: ResolvedWorkspaceTarget): string {
-  return [
-    'Pixcode orchestration execution context:',
-    `- Target workspace: ${target.label}`,
-    `- Working directory for this agent: ${target.projectPath}`,
-    target.selectedProjectName ? `- Selected UI project: ${target.selectedProjectName}` : '',
-    target.selectedProjectPath ? `- Selected UI project path: ${target.selectedProjectPath}` : '',
-    `- Pixcode app root: ${target.appRoot}`,
-    '',
-    'Rules:',
-    '- Treat the working directory above as the authoritative project/application for this task.',
-    '- Do not guess another repository path unless the user explicitly asks for it.',
-    '- Do not access parent directories, sibling projects, or broad external globs outside the working directory unless the user explicitly asks.',
-    '- If the user asks to analyze or modify Pixcode/orchestration itself, the target workspace must be the Pixcode app root.',
-    '- Before running package-manager commands, inspect the package files in the working directory.',
-    '- If a tool reports a permission denial, summarize the limitation and continue from the provided context instead of retrying the same external path.',
-  ].filter(Boolean).join('\n');
-}

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

@@ -1,136 +0,0 @@
-import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
-import type {
-  ExecResult,
-  WorkspaceHandle,
-  WorkspaceRequest,
-} from '@/modules/orchestration/workspace/types.js';
-
-async function run(
-  command: string,
-  args: string[],
-): Promise<ExecResult> {
-  try {
-    const { execFile } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const execFileAsync = promisify(execFile);
-    const { stdout, stderr } = await execFileAsync(command, args, {
-      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,
-    };
-  }
-}
-
-export class DockerWorkspace implements WorkspaceHandle {
-  readonly kind = 'docker' as const;
-  readonly id: string;
-  readonly path: string;
-  readonly baseRef: string;
-  readonly metadata: Record<string, unknown>;
-  private containerId?: string;
-  private readonly worktreePath: string;
-
-  constructor(request: WorkspaceRequest) {
-    this.id = `docker_${request.taskId}`;
-    this.path = '/workspace';
-    this.baseRef = request.baseRef ?? 'HEAD';
-    this.worktreePath = request.projectPath;
-    this.metadata = {
-      ...request.metadata,
-      image: request.metadata?.image ?? 'node:22-slim',
-      containerId: undefined,
-      exposedPorts: [],
-    };
-  }
-
-  private async ensureStarted(): Promise<void> {
-    if (this.containerId) return;
-    const image = String(this.metadata.image ?? 'node:22-slim');
-    const pullResult = await run('docker', ['pull', image]);
-    if (pullResult.exitCode !== 0) {
-      throw new WorkspaceError('WORKSPACE_DOCKER_PULL_FAILED', pullResult.stderr || pullResult.stdout, {
-        image,
-        workspaceId: this.id,
-      });
-    }
-    const createResult = await run('docker', [
-      'create',
-      '--rm',
-      '-v', `${this.worktreePath}:/workspace`,
-      '-w', '/workspace',
-      image,
-      'tail', '-f', '/dev/null',
-    ]);
-    if (createResult.exitCode !== 0 || !createResult.stdout.trim()) {
-      throw new WorkspaceError('WORKSPACE_DOCKER_CREATE_FAILED', createResult.stderr || createResult.stdout, {
-        image,
-        workspaceId: this.id,
-      });
-    }
-    this.containerId = createResult.stdout.trim();
-    const startResult = await run('docker', ['start', this.containerId]);
-    if (startResult.exitCode !== 0) {
-      await this.cleanupContainer();
-      throw new WorkspaceError('WORKSPACE_DOCKER_START_FAILED', startResult.stderr || startResult.stdout, {
-        containerId: this.containerId,
-        workspaceId: this.id,
-      });
-    }
-    this.metadata.containerId = this.containerId;
-  }
-
-  private async cleanupContainer(): Promise<void> {
-    if (!this.containerId) return;
-    await run('docker', ['rm', '-f', this.containerId]).catch(() => {});
-    this.containerId = undefined;
-  }
-
-  async exec(command: string, args: string[] = []): Promise<ExecResult> {
-    await this.ensureStarted();
-    return run('docker', ['exec', this.containerId!, command, ...args]);
-  }
-
-  async readFile(relativePath: string): Promise<string> {
-    await this.ensureStarted();
-    const result = await run('docker', ['exec', this.containerId!, 'cat', relativePath]);
-    if (result.exitCode !== 0) {
-      throw new WorkspaceError('WORKSPACE_READ_FAILED', result.stderr, { path: relativePath });
-    }
-    return result.stdout;
-  }
-
-  async writeFile(relativePath: string, content: string): Promise<void> {
-    await this.ensureStarted();
-    const result = await run('docker', ['exec', this.containerId!, 'sh', '-c', `cat > ${relativePath}`]);
-    if (result.exitCode !== 0) {
-      throw new WorkspaceError('WORKSPACE_WRITE_FAILED', result.stderr, { path: relativePath });
-    }
-  }
-
-  async diff(): Promise<string> {
-    const { execFile } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const execFileAsync = promisify(execFile);
-    try {
-      const { stdout } = await execFileAsync('git', ['diff', `${this.baseRef}...HEAD`], {
-        cwd: this.worktreePath,
-        maxBuffer: 20 * 1024 * 1024,
-      });
-      return String(stdout);
-    } catch (error) {
-      const err = error as Error & { stderr?: string };
-      const output = String(err.stderr ?? err.message);
-      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
-    }
-  }
-
-  async destroy(): Promise<void> {
-    await this.cleanupContainer();
-  }
-}

package/server/modules/orchestration/workspace/path-safety.ts

@@ -1,55 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
-
-const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
-
-export function getWorktreesRoot(): string {
-  return process.env.PIXCODE_WORKTREES_ROOT ?? path.join(os.homedir(), '.pixcode', 'worktrees');
-}
-
-export function assertSafeId(value: string, label: string): string {
-  if (!SAFE_ID.test(value) || value.includes('..')) {
-    throw new WorkspaceError('UNSAFE_WORKSPACE_ID', `Unsafe ${label}: ${value}`, { value, label });
-  }
-  return value;
-}
-
-export function ensureDirectory(dir: string): void {
-  fs.mkdirSync(dir, { recursive: true });
-}
-
-export function safeWorkspacePath(workspaceId: string): string {
-  assertSafeId(workspaceId, 'workspace id');
-  const root = getWorktreesRoot();
-  ensureDirectory(root);
-  const resolvedRoot = fs.realpathSync.native(root);
-  const target = path.resolve(resolvedRoot, workspaceId);
-  if (!target.startsWith(`${resolvedRoot}${path.sep}`)) {
-    throw new WorkspaceError('WORKSPACE_PATH_TRAVERSAL', 'Workspace path escaped root', {
-      root: resolvedRoot,
-      target,
-    });
-  }
-  return target;
-}
-
-export function safeJoin(root: string, relativePath: string): string {
-  if (path.isAbsolute(relativePath) || relativePath.includes('\0')) {
-    throw new WorkspaceError('WORKSPACE_PATH_TRAVERSAL', 'Workspace file path must be relative', {
-      relativePath,
-    });
-  }
-
-  const target = path.resolve(root, relativePath);
-  const resolvedRoot = fs.existsSync(root) ? fs.realpathSync.native(root) : path.resolve(root);
-  if (!target.startsWith(`${resolvedRoot}${path.sep}`) && target !== resolvedRoot) {
-    throw new WorkspaceError('WORKSPACE_PATH_TRAVERSAL', 'Workspace file path escaped root', {
-      root: resolvedRoot,
-      target,
-    });
-  }
-  return target;
-}

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

@@ -1,52 +0,0 @@
-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,102 +0,0 @@
-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 insideWorkTree = await this.exec('git', ['rev-parse', '--is-inside-work-tree']);
-    if (insideWorkTree.exitCode !== 0 || insideWorkTree.stdout.trim() !== 'true') {
-      return '';
-    }
-
-    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,126 +0,0 @@
-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) {
-      const output = result.stderr || result.stdout;
-      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
-    }
-    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,
-      });
-    }
-  }
-}