mcp-copilot-cli 1.0.0

package/src/services/task-persistence.ts

@@ -0,0 +1,100 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type { PersistedProfileState, PersistedWorkspaceState, TaskRecord } from '../types/task.js';
+import { TaskStatus } from '../types/task.js';
+
+export interface SaveWorkspaceStateInput {
+  cwd: string;
+  storageRoot?: string | undefined;
+  tasks: TaskRecord[];
+  profiles: PersistedProfileState[];
+}
+
+export interface LoadWorkspaceStateInput {
+  cwd: string;
+  storageRoot?: string | undefined;
+}
+
+export interface LoadedWorkspaceState {
+  tasks: TaskRecord[];
+  profiles: PersistedProfileState[];
+}
+
+const STORAGE_DIR_NAME = '.super-agents';
+
+export function defaultStorageRoot(): string {
+  return join(homedir(), STORAGE_DIR_NAME);
+}
+
+export function getWorkspaceStatePath(cwd: string, storageRoot = defaultStorageRoot()): string {
+  const digest = createHash('md5').update(cwd).digest('hex');
+  return join(storageRoot, `${digest}.json`);
+}
+
+function recoverTask(task: TaskRecord): TaskRecord {
+  if (task.status === TaskStatus.RATE_LIMITED) {
+    return task;
+  }
+
+  if (
+    task.status === TaskStatus.RUNNING ||
+    task.status === TaskStatus.PENDING ||
+    task.status === TaskStatus.WAITING ||
+    task.status === TaskStatus.WAITING_ANSWER
+  ) {
+    return {
+      ...task,
+      status: TaskStatus.FAILED,
+      error: 'Server restarted while task was active',
+      endTime: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  return task;
+}
+
+export async function saveWorkspaceState(input: SaveWorkspaceStateInput): Promise<void> {
+  const storageRoot = input.storageRoot ?? defaultStorageRoot();
+  const path = getWorkspaceStatePath(input.cwd, storageRoot);
+  const tempPath = `${path}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+
+  await mkdir(storageRoot, { recursive: true });
+
+  const payload: PersistedWorkspaceState = {
+    version: 1,
+    tasks: input.tasks,
+    profiles: input.profiles,
+  };
+
+  await writeFile(tempPath, JSON.stringify(payload, null, 2), 'utf8');
+  await rename(tempPath, path);
+}
+
+export async function loadWorkspaceState(input: LoadWorkspaceStateInput): Promise<LoadedWorkspaceState> {
+  const storageRoot = input.storageRoot ?? defaultStorageRoot();
+  const path = getWorkspaceStatePath(input.cwd, storageRoot);
+
+  try {
+    const raw = await readFile(path, 'utf8');
+    const parsed = JSON.parse(raw) as PersistedWorkspaceState;
+
+    return {
+      tasks: parsed.tasks.map(recoverTask),
+      profiles: parsed.profiles ?? [],
+    };
+  } catch {
+    return {
+      tasks: [],
+      profiles: [],
+    };
+  }
+}
+
+export async function deleteWorkspaceState(cwd: string, storageRoot?: string): Promise<void> {
+  const path = getWorkspaceStatePath(cwd, storageRoot ?? defaultStorageRoot());
+  await unlink(path).catch(() => {});
+}

package/src/services/task-store.ts

@@ -0,0 +1,207 @@
+import { uniqueNamesGenerator, adjectives, animals, NumberDictionary } from 'unique-names-generator';
+
+import type { CreateTaskInput, TaskRecord } from '../types/task.js';
+import { TaskStatus, isTerminalStatus } from '../types/task.js';
+
+const numberDictionary = NumberDictionary.generate({ min: 1, max: 9999 });
+
+const VALID_TRANSITIONS: Record<TaskStatus, Set<TaskStatus>> = {
+  [TaskStatus.PENDING]: new Set([TaskStatus.RUNNING, TaskStatus.WAITING, TaskStatus.WAITING_ANSWER, TaskStatus.COMPLETED, TaskStatus.CANCELLED, TaskStatus.FAILED, TaskStatus.TIMED_OUT]),
+  [TaskStatus.WAITING]: new Set([TaskStatus.PENDING, TaskStatus.WAITING_ANSWER, TaskStatus.COMPLETED, TaskStatus.CANCELLED, TaskStatus.FAILED, TaskStatus.TIMED_OUT]),
+  [TaskStatus.RUNNING]: new Set([TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED, TaskStatus.RATE_LIMITED, TaskStatus.WAITING_ANSWER, TaskStatus.TIMED_OUT]),
+  [TaskStatus.WAITING_ANSWER]: new Set([TaskStatus.RUNNING, TaskStatus.FAILED, TaskStatus.CANCELLED, TaskStatus.TIMED_OUT]),
+  [TaskStatus.COMPLETED]: new Set(),
+  [TaskStatus.FAILED]: new Set(),
+  [TaskStatus.CANCELLED]: new Set(),
+  [TaskStatus.RATE_LIMITED]: new Set([TaskStatus.RUNNING, TaskStatus.FAILED, TaskStatus.CANCELLED, TaskStatus.TIMED_OUT]),
+  [TaskStatus.TIMED_OUT]: new Set(),
+};
+
+function generateTaskId(existingIds: Set<string>): string {
+  let next = uniqueNamesGenerator({
+    dictionaries: [adjectives, animals, numberDictionary],
+    separator: '-',
+    style: 'lowerCase',
+  });
+
+  while (existingIds.has(next)) {
+    next = uniqueNamesGenerator({
+      dictionaries: [adjectives, animals, numberDictionary],
+      separator: '-',
+      style: 'lowerCase',
+    });
+  }
+
+  return next;
+}
+
+function dependenciesSatisfied(task: TaskRecord, tasks: Map<string, TaskRecord>): boolean {
+  return (task.dependsOn ?? []).every((dependencyId) => tasks.get(dependencyId)?.status === TaskStatus.COMPLETED);
+}
+
+function circularDependencyPath(
+  tasks: Map<string, TaskRecord>,
+  startId: string,
+  newDependsOn?: string[],
+): string[] | null {
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const trail: string[] = [];
+
+  const visit = (taskId: string): string[] | null => {
+    if (visiting.has(taskId)) {
+      const index = trail.indexOf(taskId);
+      return [...trail.slice(index), taskId];
+    }
+    if (visited.has(taskId)) {
+      return null;
+    }
+
+    visiting.add(taskId);
+    trail.push(taskId);
+
+    const dependsOn = taskId === startId && newDependsOn !== undefined
+      ? newDependsOn
+      : tasks.get(taskId)?.dependsOn ?? [];
+
+    for (const dependencyId of dependsOn) {
+      const cycle = visit(dependencyId);
+      if (cycle) {
+        return cycle;
+      }
+    }
+
+    trail.pop();
+    visiting.delete(taskId);
+    visited.add(taskId);
+    return null;
+  };
+
+  return visit(startId);
+}
+
+export class TaskStore {
+  private readonly tasks = new Map<string, TaskRecord>();
+
+  createTask(input: CreateTaskInput): TaskRecord {
+    const id = generateTaskId(new Set(this.tasks.keys()));
+    const dependencyError = this.validateDependencies(input.dependsOn ?? [], id);
+    if (dependencyError) {
+      throw new Error(dependencyError);
+    }
+
+    const now = new Date().toISOString();
+    const task: TaskRecord = {
+      id,
+      status: (input.dependsOn?.length ?? 0) > 0 ? TaskStatus.WAITING : TaskStatus.PENDING,
+      prompt: input.prompt,
+      cwd: input.cwd,
+      model: input.model,
+      agentType: input.agentType,
+      output: [],
+      startTime: now,
+      createdAt: now,
+      updatedAt: now,
+      labels: input.labels ?? [],
+      contextFiles: input.contextFiles ?? [],
+      dependsOn: input.dependsOn?.length ? [...input.dependsOn] : undefined,
+      timeoutMs: input.timeoutMs,
+      sessionId: input.sessionId,
+      parentTaskId: input.parentTaskId,
+      profileId: input.profileId,
+      profileConfigDir: input.profileConfigDir,
+      isolationMode: input.isolationMode,
+      baseCwd: input.baseCwd,
+    };
+
+    if (task.status === TaskStatus.WAITING && dependenciesSatisfied(task, this.tasks)) {
+      task.status = TaskStatus.PENDING;
+    }
+
+    this.tasks.set(task.id, task);
+    return task;
+  }
+
+  getTask(taskId: string): TaskRecord | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  getAllTasks(): TaskRecord[] {
+    return [...this.tasks.values()];
+  }
+
+  importTask(task: TaskRecord): void {
+    this.tasks.set(task.id, task);
+  }
+
+  validateDependencies(dependsOn: string[], newTaskId?: string): string | null {
+    if (dependsOn.length === 0) {
+      return null;
+    }
+
+    if (new Set(dependsOn).size !== dependsOn.length) {
+      return 'Duplicate dependency IDs are not allowed';
+    }
+
+    if (newTaskId && dependsOn.includes(newTaskId)) {
+      return `Task '${newTaskId}' cannot depend on itself`;
+    }
+
+    for (const dependencyId of dependsOn) {
+      if (!this.tasks.has(dependencyId)) {
+        return `Dependency task '${dependencyId}' not found`;
+      }
+    }
+
+    if (newTaskId) {
+      const cycle = circularDependencyPath(this.tasks, newTaskId, dependsOn);
+      if (cycle) {
+        return `Circular dependency detected: ${cycle.join(' -> ')}`;
+      }
+    }
+
+    return null;
+  }
+
+  updateTask(taskId: string, updates: Partial<TaskRecord>): TaskRecord | undefined {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return undefined;
+    }
+
+    if (updates.status && updates.status !== task.status) {
+      if (isTerminalStatus(task.status)) {
+        return task;
+      }
+      const allowed = VALID_TRANSITIONS[task.status];
+      if (!allowed.has(updates.status)) {
+        return task;
+      }
+    }
+
+    Object.assign(task, updates, { updatedAt: new Date().toISOString() });
+    return task;
+  }
+
+  releaseReadyTasks(): TaskRecord[] {
+    const released: TaskRecord[] = [];
+
+    for (const task of this.tasks.values()) {
+      if (task.status !== TaskStatus.WAITING) {
+        continue;
+      }
+
+      if (dependenciesSatisfied(task, this.tasks)) {
+        task.status = TaskStatus.PENDING;
+        task.updatedAt = new Date().toISOString();
+        released.push(task);
+      }
+    }
+
+    return released;
+  }
+
+  clear(): void {
+    this.tasks.clear();
+  }
+}

package/src/services/workspace-isolation.ts

@@ -0,0 +1,100 @@
+import { cp, mkdir, readdir, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export type IsolationMode = 'shared' | 'isolated';
+
+export interface PreparedWorkspace {
+  cwd: string;
+  cleanupRequired: boolean;
+  mode: 'shared' | 'copy' | 'worktree';
+}
+
+export interface PrepareTaskWorkspaceInput {
+  baseCwd: string;
+  taskId: string;
+  isolationMode: IsolationMode;
+}
+
+const SKIP_NAMES = new Set(['.git', 'node_modules', '.super-agents', '.worktrees', 'worktrees', 'dist']);
+
+export async function prepareTaskWorkspace(input: PrepareTaskWorkspaceInput): Promise<PreparedWorkspace> {
+  if (input.isolationMode === 'shared') {
+    return {
+      cwd: input.baseCwd,
+      cleanupRequired: false,
+      mode: 'shared',
+    };
+  }
+
+  const worktree = await tryCreateGitWorktree(input);
+  if (worktree) {
+    return worktree;
+  }
+
+  const copyRoot = join(input.baseCwd, '.super-agents', 'workspaces', input.taskId);
+  await mkdir(dirname(copyRoot), { recursive: true });
+  await rm(copyRoot, { recursive: true, force: true });
+  await mkdir(copyRoot, { recursive: true });
+
+  const topLevelEntries = await readdir(input.baseCwd);
+  for (const entry of topLevelEntries) {
+    if (SKIP_NAMES.has(entry)) {
+      continue;
+    }
+
+    await cp(join(input.baseCwd, entry), join(copyRoot, entry), {
+      recursive: true,
+      filter(source) {
+        return !SKIP_NAMES.has(source.split('/').pop() ?? '');
+      },
+    });
+  }
+
+  return {
+    cwd: copyRoot,
+    cleanupRequired: true,
+    mode: 'copy',
+  };
+}
+
+export async function cleanupPreparedWorkspace(workspace: PreparedWorkspace): Promise<void> {
+  if (!workspace.cleanupRequired || workspace.mode === 'shared') {
+    return;
+  }
+
+  await rm(workspace.cwd, { recursive: true, force: true });
+}
+
+async function tryCreateGitWorktree(input: PrepareTaskWorkspaceInput): Promise<PreparedWorkspace | null> {
+  try {
+    const { stdout: rootStdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: input.baseCwd,
+    });
+    const gitRoot = rootStdout.trim();
+    if (!gitRoot) {
+      return null;
+    }
+
+    await execFileAsync('git', ['rev-parse', '--verify', 'HEAD'], {
+      cwd: gitRoot,
+    });
+
+    const worktreePath = join(gitRoot, '.worktrees', input.taskId);
+    await mkdir(dirname(worktreePath), { recursive: true });
+    await execFileAsync('git', ['worktree', 'add', '--detach', worktreePath, 'HEAD'], {
+      cwd: gitRoot,
+    });
+
+    return {
+      cwd: worktreePath,
+      cleanupRequired: true,
+      mode: 'worktree',
+    };
+  } catch {
+    return null;
+  }
+}

package/src/templates/agent-prompt.ts

@@ -0,0 +1,71 @@
+import { readFile } from 'node:fs/promises';
+
+import type { AgentType, ContextFile } from '../types/task.js';
+
+const ROLE_TEMPLATES: Record<AgentType, string> = {
+  coder: [
+    'You are the implementation agent.',
+    'Work carefully, change as little as needed, and verify the requested behavior.',
+    'Prefer deterministic edits over speculative refactors.',
+  ].join(' '),
+  planner: [
+    'You are the planning agent.',
+    'Clarify scope, constraints, risks, and the concrete implementation path.',
+    'Produce actionable implementation guidance instead of vague advice.',
+  ].join(' '),
+  researcher: [
+    'You are the research agent.',
+    'Investigate the code and runtime behavior before proposing conclusions.',
+    'Surface the facts that a downstream implementer needs.',
+  ].join(' '),
+  tester: [
+    'You are the testing agent.',
+    'Exercise the real behavior, collect evidence, and describe failures concretely.',
+    'Prefer end-to-end verification when possible.',
+  ].join(' '),
+  general: [
+    'You are a general-purpose autonomous agent.',
+    'Stay focused on the requested deliverable and keep your output concrete.',
+  ].join(' '),
+};
+
+async function renderContextFiles(contextFiles: ContextFile[]): Promise<string> {
+  if (contextFiles.length === 0) {
+    return '';
+  }
+
+  const sections = await Promise.all(
+    contextFiles.map(async (contextFile) => {
+      const content = await readFile(contextFile.path, 'utf8');
+      return [
+        `## Context File: ${contextFile.path}`,
+        contextFile.description ? `Description: ${contextFile.description}` : null,
+        '',
+        '```text',
+        content,
+        '```',
+      ].filter(Boolean).join('\n');
+    }),
+  );
+
+  return sections.join('\n\n');
+}
+
+export async function buildAgentPrompt(input: {
+  agentType: AgentType;
+  prompt: string;
+  contextFiles: ContextFile[];
+}): Promise<string> {
+  const context = await renderContextFiles(input.contextFiles);
+
+  return [
+    ROLE_TEMPLATES[input.agentType],
+    '',
+    'Treat the task as stateful background work. If you need user input, ask a concise question.',
+    '',
+    '## Assignment',
+    input.prompt,
+    context ? '' : null,
+    context || null,
+  ].filter(Boolean).join('\n');
+}

package/src/types/task.ts

@@ -0,0 +1,95 @@
+export type AgentType = 'coder' | 'planner' | 'researcher' | 'tester' | 'general';
+
+export interface ContextFile {
+  path: string;
+  description?: string | undefined;
+}
+
+export interface PendingQuestion {
+  question: string;
+  choices?: string[] | undefined;
+  allowFreeform: boolean;
+  askedAt: string;
+  sessionId: string;
+}
+
+export enum TaskStatus {
+  PENDING = 'pending',
+  WAITING = 'waiting',
+  RUNNING = 'running',
+  WAITING_ANSWER = 'waiting_answer',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  CANCELLED = 'cancelled',
+  RATE_LIMITED = 'rate_limited',
+  TIMED_OUT = 'timed_out',
+}
+
+export const TERMINAL_STATUSES = new Set<TaskStatus>([
+  TaskStatus.COMPLETED,
+  TaskStatus.FAILED,
+  TaskStatus.CANCELLED,
+  TaskStatus.TIMED_OUT,
+]);
+
+export function isTerminalStatus(status: TaskStatus): boolean {
+  return TERMINAL_STATUSES.has(status);
+}
+
+export interface TaskRecord {
+  id: string;
+  status: TaskStatus;
+  prompt: string;
+  cwd: string;
+  model: string;
+  agentType: AgentType;
+  output: string[];
+  startTime: string;
+  createdAt: string;
+  updatedAt: string;
+  labels: string[];
+  contextFiles: ContextFile[];
+  dependsOn?: string[] | undefined;
+  error?: string | undefined;
+  endTime?: string | undefined;
+  outputFilePath?: string | undefined;
+  timeoutMs?: number | undefined;
+  sessionId?: string | undefined;
+  parentTaskId?: string | undefined;
+  pendingQuestion?: PendingQuestion | undefined;
+  profileId?: string | undefined;
+  profileConfigDir?: string | undefined;
+  isolationMode?: 'shared' | 'isolated' | undefined;
+  baseCwd?: string | undefined;
+}
+
+export interface CreateTaskInput {
+  prompt: string;
+  cwd: string;
+  model: string;
+  agentType: AgentType;
+  labels?: string[] | undefined;
+  contextFiles?: ContextFile[] | undefined;
+  dependsOn?: string[] | undefined;
+  timeoutMs?: number | undefined;
+  sessionId?: string | undefined;
+  parentTaskId?: string | undefined;
+  profileId?: string | undefined;
+  profileConfigDir?: string | undefined;
+  isolationMode?: 'shared' | 'isolated' | undefined;
+  baseCwd?: string | undefined;
+}
+
+export interface PersistedWorkspaceState {
+  version: 1;
+  tasks: TaskRecord[];
+  profiles: PersistedProfileState[];
+}
+
+export interface PersistedProfileState {
+  id: string;
+  configDir: string;
+  cooldownUntil?: number | undefined;
+  failureCount: number;
+  lastFailureReason?: string | undefined;
+}