@openforge-app/plugin-sdk 0.2.10 → 0.3.0

package/dist/mermaidZoom.js

@@ -0,0 +1,52 @@
+export const MIN_MERMAID_ZOOM = 0.25;
+export const MAX_MERMAID_ZOOM = 4;
+export const MERMAID_ZOOM_STEP = 0.25;
+export const FIT_MERMAID_ZOOM = { mode: 'fit' };
+function isPositiveSize(size) {
+    return Number.isFinite(size.width)
+        && Number.isFinite(size.height)
+        && size.width > 0
+        && size.height > 0;
+}
+function clampManualScale(scale) {
+    if (!Number.isFinite(scale))
+        return 1;
+    return Math.min(MAX_MERMAID_ZOOM, Math.max(MIN_MERMAID_ZOOM, scale));
+}
+function normalizeScale(scale) {
+    return Math.round(scale * 10_000) / 10_000;
+}
+export function calculateMermaidFitScale(content, viewport) {
+    if (!isPositiveSize(content) || !isPositiveSize(viewport))
+        return null;
+    return Math.min(viewport.width / content.width, viewport.height / content.height);
+}
+export function createManualMermaidZoom(scale) {
+    return { mode: 'manual', scale: clampManualScale(scale) };
+}
+export function resolveMermaidZoomScale(state, fitScale) {
+    if (state.mode === 'manual')
+        return state.scale;
+    return fitScale && fitScale > 0 ? fitScale : 1;
+}
+export function zoomMermaidIn(state, fitScale) {
+    const currentScale = resolveMermaidZoomScale(state, fitScale);
+    return createManualMermaidZoom(normalizeScale(currentScale + MERMAID_ZOOM_STEP));
+}
+export function zoomMermaidOut(state, fitScale) {
+    const currentScale = resolveMermaidZoomScale(state, fitScale);
+    return createManualMermaidZoom(normalizeScale(currentScale - MERMAID_ZOOM_STEP));
+}
+export function resetMermaidZoom() {
+    return createManualMermaidZoom(1);
+}
+export function canZoomMermaidIn(state, fitScale) {
+    return resolveMermaidZoomScale(state, fitScale) < MAX_MERMAID_ZOOM;
+}
+export function canZoomMermaidOut(state, fitScale) {
+    return resolveMermaidZoomScale(state, fitScale) > MIN_MERMAID_ZOOM;
+}
+export function formatMermaidZoomLabel(state, fitScale) {
+    const percentage = Math.round(resolveMermaidZoomScale(state, fitScale) * 100);
+    return state.mode === 'fit' ? `Fit (${percentage}%)` : `${percentage}%`;
+}

package/dist/publicEntrypoints.d.mts

@@ -20,6 +20,7 @@ export function createOpenForgePluginSdkPackageExports(): Record<
 
 export function createOpenForgePluginSdkTypeScriptPaths(): Record<string, [string]>
 
+export function loadOpenForgePluginSdkTypeScriptPaths(workspaceRoot: string): Promise<Record<string, unknown>>
 export function assertOpenForgePluginSdkEntrypointRegistries(registries: {
   packageExports: unknown
   typeScriptPaths: unknown

package/dist/publicEntrypoints.mjs

@@ -1,4 +1,6 @@
-import { isDeepStrictEqual } from 'node:util'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { assertRegistryMatchesCanonicalManifest } from './registryValidation.mjs'
 import { OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS } from './publicUiExports.mjs'
 
 const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
@@ -77,27 +79,26 @@ export function createOpenForgePluginSdkTypeScriptPaths() {
   )
 }
 
-export function assertOpenForgePluginSdkEntrypointRegistries({ packageExports, typeScriptPaths }) {
-  assertRegistryMatches('package exports', packageExports, createOpenForgePluginSdkPackageExports())
-  assertRegistryMatches('root TypeScript paths', typeScriptPaths, createOpenForgePluginSdkTypeScriptPaths())
-}
-
-function assertRegistryMatches(registryName, actual, expected) {
-  if (!actual || typeof actual !== 'object' || Array.isArray(actual)) {
-    throw new Error(`Plugin SDK ${registryName} must be an object`)
-  }
-
-  const missingOrMismatched = Object.entries(expected)
-    .filter(([key, value]) => !isDeepStrictEqual(actual[key], value))
-    .map(([key]) => key)
-  const unexpected = Object.keys(actual).filter((key) => !(key in expected))
-
-  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
+export async function loadOpenForgePluginSdkTypeScriptPaths(workspaceRoot) {
+  const typeScriptConfig = JSON.parse(
+    (await readFile(resolve(workspaceRoot, 'tsconfig.json'), 'utf8')).replace(/\/\*[\s\S]*?\*\//g, ''),
+  )
 
-  const details = [
-    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
-    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
-  ].filter(Boolean)
+  return Object.fromEntries(
+    Object.entries(typeScriptConfig.compilerOptions.paths)
+      .filter(([specifier]) => specifier === PLUGIN_SDK_PACKAGE_NAME || specifier.startsWith(`${PLUGIN_SDK_PACKAGE_NAME}/`)),
+  )
+}
 
-  throw new Error(`Plugin SDK ${registryName} drifted from the canonical manifest (${details.join('; ')})`)
+export function assertOpenForgePluginSdkEntrypointRegistries({ packageExports, typeScriptPaths }) {
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK package exports',
+    actual: packageExports,
+    expected: createOpenForgePluginSdkPackageExports(),
+  })
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK root TypeScript paths',
+    actual: typeScriptPaths,
+    expected: createOpenForgePluginSdkTypeScriptPaths(),
+  })
 }

package/dist/publicUiExports.mjs

@@ -1,3 +1,5 @@
+import { assertRegistryMatchesCanonicalManifest } from './registryValidation.mjs'
+
 const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
 
 const PUBLIC_UI_COMPONENT_NAMES = Object.freeze([
@@ -38,26 +40,12 @@ export function createOpenForgePluginSdkPublicUiPackageExports() {
 }
 
 export function assertOpenForgePluginSdkPublicUiPackageExports(packageExports) {
-  if (!packageExports || typeof packageExports !== 'object' || Array.isArray(packageExports)) {
-    throw new Error('Plugin SDK package.json must define an exports object')
-  }
-
-  const expected = createOpenForgePluginSdkPublicUiPackageExports()
-  const actual = Object.fromEntries(
-    Object.entries(packageExports).filter(([subpath]) => subpath.startsWith('./ui/')),
-  )
-  const expectedEntries = Object.entries(expected)
-  const missingOrMismatched = expectedEntries
-    .filter(([subpath, distPath]) => actual[subpath] !== distPath)
-    .map(([subpath, distPath]) => `${subpath} -> ${distPath}`)
-  const unexpected = Object.keys(actual).filter((subpath) => !(subpath in expected))
-
-  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
-
-  const details = [
-    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
-    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
-  ].filter(Boolean)
-
-  throw new Error(`Plugin SDK public UI exports drifted from the canonical manifest (${details.join('; ')})`)
+  assertRegistryMatchesCanonicalManifest({
+    registryName: 'Plugin SDK public UI exports',
+    actual: packageExports,
+    expected: createOpenForgePluginSdkPublicUiPackageExports(),
+    invalidRegistryMessage: 'Plugin SDK package.json must define an exports object',
+    includeActualEntry: ([subpath]) => subpath.startsWith('./ui/'),
+    formatMissingOrMismatched: ([subpath, distPath]) => `${subpath} -> ${distPath}`,
+  })
 }

package/dist/registryValidation.d.mts

@@ -0,0 +1,11 @@
+type Registry = Record<string, unknown>
+type RegistryEntry = [string, unknown]
+
+export function assertRegistryMatchesCanonicalManifest(options: {
+  registryName: string
+  actual: unknown
+  expected: Registry
+  invalidRegistryMessage?: string
+  includeActualEntry?: (entry: RegistryEntry) => boolean
+  formatMissingOrMismatched?: (entry: RegistryEntry) => string
+}): void

package/dist/registryValidation.mjs

@@ -0,0 +1,30 @@
+import { isDeepStrictEqual } from 'node:util'
+
+export function assertRegistryMatchesCanonicalManifest({
+  registryName,
+  actual,
+  expected,
+  invalidRegistryMessage = `${registryName} must be an object`,
+  includeActualEntry = () => true,
+  formatMissingOrMismatched = ([key]) => key,
+}) {
+  if (!actual || typeof actual !== 'object' || Array.isArray(actual)) {
+    throw new Error(invalidRegistryMessage)
+  }
+
+  const comparableActual = Object.fromEntries(Object.entries(actual).filter(includeActualEntry))
+
+  const missingOrMismatched = Object.entries(expected)
+    .filter(([key, value]) => !isDeepStrictEqual(comparableActual[key], value))
+    .map(formatMissingOrMismatched)
+  const unexpected = Object.keys(comparableActual).filter((key) => !(key in expected))
+
+  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
+
+  const details = [
+    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
+    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
+  ].filter(Boolean)
+
+  throw new Error(`${registryName} drifted from the canonical manifest (${details.join('; ')})`)
+}

package/dist/sanitize.d.ts

@@ -4,3 +4,5 @@
  * Allows safe structural/formatting HTML through.
  */
 export declare function sanitizeHtml(dirty: string): string;
+/** Sanitize generated Mermaid SVG before it is inserted into the document. */
+export declare function sanitizeMermaidSvg(dirty: string): string;

package/dist/sanitize.js

@@ -11,3 +11,134 @@ export function sanitizeHtml(dirty) {
         FORBID_ATTR: ['style'],
     });
 }
+const SAFE_MERMAID_STYLE_PROPERTIES = new Set([
+    'color',
+    'dominant-baseline',
+    'fill',
+    'fill-opacity',
+    'font-family',
+    'font-size',
+    'font-style',
+    'font-weight',
+    'max-width',
+    'opacity',
+    'stroke',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-opacity',
+    'stroke-width',
+    'text-align',
+    'text-anchor',
+    'white-space',
+]);
+function getSafeMermaidStyleDeclarations(style) {
+    const safeDeclarations = [];
+    for (const property of Array.from(style)) {
+        if (!SAFE_MERMAID_STYLE_PROPERTIES.has(property))
+            continue;
+        const value = style.getPropertyValue(property);
+        if (/url\s*\(|expression\s*\(|javascript:|data:|@import|var\s*\(/i.test(value))
+            continue;
+        const priority = style.getPropertyPriority(property);
+        safeDeclarations.push(`${property}: ${value}${priority ? ` !${priority}` : ''}`);
+    }
+    return safeDeclarations;
+}
+function removeCssAtRules(css) {
+    let result = '';
+    let index = 0;
+    while (index < css.length) {
+        if (css[index] !== '@') {
+            result += css[index++];
+            continue;
+        }
+        let depth = 0;
+        let quote = '';
+        for (; index < css.length; index++) {
+            const character = css[index];
+            if (quote) {
+                if (character === '\\')
+                    index++;
+                else if (character === quote)
+                    quote = '';
+                continue;
+            }
+            if (character === '"' || character === "'") {
+                quote = character;
+            }
+            else if (character === '{') {
+                depth++;
+            }
+            else if (character === '}') {
+                if (--depth <= 0) {
+                    index++;
+                    break;
+                }
+            }
+            else if (character === ';' && depth === 0) {
+                index++;
+                break;
+            }
+        }
+    }
+    return result;
+}
+function sanitizeMermaidStylesheet(css, styleParser) {
+    const withoutComments = css.replace(/\/\*[\s\S]*?\*\//g, '');
+    const safeRuleSource = removeCssAtRules(withoutComments);
+    const rules = [];
+    const rulePattern = /([^{}]+)\{([^{}]*)\}/g;
+    let consumedUntil = 0;
+    let match;
+    while ((match = rulePattern.exec(safeRuleSource)) !== null) {
+        if (safeRuleSource.slice(consumedUntil, match.index).trim())
+            return '';
+        consumedUntil = rulePattern.lastIndex;
+        const selector = match[1].trim();
+        if (!selector || /[{}@\\]/.test(selector))
+            continue;
+        styleParser.setAttribute('style', match[2]);
+        const declarations = getSafeMermaidStyleDeclarations(styleParser.style);
+        if (declarations.length > 0)
+            rules.push(`${selector} { ${declarations.join('; ')} }`);
+    }
+    if (safeRuleSource.slice(consumedUntil).trim())
+        return '';
+    return rules.join('\n');
+}
+function sanitizeMermaidStyles(svg) {
+    const template = document.createElement('template');
+    template.innerHTML = svg;
+    const styleParser = document.createElement('span');
+    for (const element of template.content.querySelectorAll('[style]')) {
+        styleParser.setAttribute('style', element.getAttribute('style') ?? '');
+        const safeDeclarations = getSafeMermaidStyleDeclarations(styleParser.style);
+        if (safeDeclarations.length > 0) {
+            element.setAttribute('style', safeDeclarations.join('; '));
+        }
+        else {
+            element.removeAttribute('style');
+        }
+    }
+    for (const style of template.content.querySelectorAll('style')) {
+        const sanitized = sanitizeMermaidStylesheet(style.textContent ?? '', styleParser);
+        if (sanitized) {
+            style.textContent = sanitized;
+        }
+        else {
+            style.remove();
+        }
+    }
+    return template.innerHTML;
+}
+/** Sanitize generated Mermaid SVG before it is inserted into the document. */
+export function sanitizeMermaidSvg(dirty) {
+    const sanitized = DOMPurify.sanitize(dirty, {
+        USE_PROFILES: { svg: true, svgFilters: true },
+        FORBID_TAGS: ['script', 'foreignObject', 'iframe', 'object', 'embed', 'image', 'a'],
+        FORBID_ATTR: ['href', 'xlink:href', 'target'],
+    });
+    return sanitizeMermaidStyles(sanitized);
+}

package/dist/testing/commonApiFake.d.ts

@@ -1,14 +1,16 @@
-import type { BackendOpenForgeAPI, FrontendOpenForgeAPI, OpenForgeCommonAPI } from '../types';
+import type { BackendOpenForgeAPI, FrontendOpenForgeAPI, TaskChangeEvent, OpenForgeCommonAPI } from '../types';
 import { type TestingRegistryServices } from './support.js';
 import type { TestingCommandContribution, TestingEventListenerContribution } from './contracts';
-export type TestingCommonApi = OpenForgeCommonAPI & Pick<FrontendOpenForgeAPI, 'navigation'>;
+export type TestingCommonApi = Omit<OpenForgeCommonAPI, 'tasks'> & Pick<FrontendOpenForgeAPI, 'tasks' | 'navigation'>;
 export declare class TestingCommonApiFake {
     private readonly services;
     private readonly commands;
     private readonly eventListeners;
     private readonly eventHandlers;
+    private readonly taskChangeHandlers;
     private eventListenerSequence;
     constructor(services: TestingRegistryServices);
+    emitTaskChange(event: TaskChangeEvent): void;
     createApi(): TestingCommonApi;
     createBackendApi(): TestingCommonApi & Pick<BackendOpenForgeAPI, 'fs'>;
     getSnapshot(): {

package/dist/testing/commonApiFake.js

@@ -2,6 +2,39 @@ import { MAX_AGENT_SESSION_PAGE_SIZE, resolveExternalTextFileChunkSize } from '.
 import { assertFunction, assertTitle, commandDescriptor, createDisposable, isJsonValue, normalizeAgentCommandMetadata, } from './support.js';
 const UTF8_ENCODER = new TextEncoder();
 const UTF8_DECODER = new TextDecoder('utf-8', { fatal: true });
+function readTestingUserDataDir(files, directoryPath) {
+    const prefix = directoryPath ? `${directoryPath}/` : '';
+    const entries = new Map();
+    for (const [filePath, content] of files) {
+        if (!filePath.startsWith(prefix))
+            continue;
+        const childPath = filePath.slice(prefix.length);
+        const separatorIndex = childPath.indexOf('/');
+        const name = separatorIndex === -1 ? childPath : childPath.slice(0, separatorIndex);
+        if (!name)
+            continue;
+        entries.set(name, separatorIndex === -1
+            ? {
+                name,
+                path: `${prefix}${name}`,
+                isDir: false,
+                size: UTF8_ENCODER.encode(content).byteLength,
+                modifiedAt: null,
+            }
+            : {
+                name,
+                path: `${prefix}${name}`,
+                isDir: true,
+                size: null,
+                modifiedAt: null,
+            });
+    }
+    return [...entries.values()].sort((left, right) => {
+        if (left.isDir !== right.isDir)
+            return left.isDir ? -1 : 1;
+        return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+    });
+}
 const TERMINAL_AGENT_SESSION_STATUSES = new Set(['completed', 'failed', 'interrupted']);
 function encodeAgentSessionCursor(payload) {
     const bytes = UTF8_ENCODER.encode(JSON.stringify(payload));
@@ -82,15 +115,172 @@ function* splitExternalTextFile(content, maxBytes) {
     if (chunk.length > 0)
         yield chunk;
 }
+function isTestingImageReferenceDefinition(line) {
+    const separator = line.indexOf(':');
+    if (separator < 0)
+        return false;
+    const marker = line.slice(0, separator);
+    const value = line.slice(separator + 1);
+    const imageNumber = marker.startsWith('[image#') && marker.endsWith(']')
+        ? marker.slice('[image#'.length, -1)
+        : null;
+    return imageNumber !== null
+        && imageNumber.length > 0
+        && /^\d+$/u.test(imageNumber)
+        && value.trimStart().startsWith('data:image/')
+        && value.includes(';base64,');
+}
+function testingTaskPromptPreview(task) {
+    const lines = task.initial_prompt
+        .split(/\r?\n/u)
+        .filter(line => !isTestingImageReferenceDefinition(line));
+    while (lines.at(-1)?.trim() === '')
+        lines.pop();
+    return [...lines.join('\n')].slice(0, 120).join('');
+}
+function testingTaskTitle(task, preview) {
+    const explicitTitle = task.title?.trim();
+    if (explicitTitle)
+        return explicitTitle;
+    const fallback = preview.split(/\r?\n/u).map(line => line.trim()).find(Boolean) || task.id;
+    return [...fallback].slice(0, 120).join('');
+}
+function taskReference(task) {
+    const preview = testingTaskPromptPreview(task);
+    if (!task.project_id)
+        throw new Error(`Task ${task.id} must belong to a project`);
+    return {
+        id: task.id,
+        status: task.status,
+        projectId: task.project_id,
+        title: testingTaskTitle(task, preview),
+        dependsOn: [...task.depends_on],
+    };
+}
+function taskSummary(task, labels = []) {
+    return {
+        ...taskReference(task),
+        createdAt: task.created_at,
+        updatedAt: task.updated_at,
+        promptPreview: testingTaskPromptPreview(task),
+        labels: [...labels],
+        sourceTicketUrl: task.source_ticket_url,
+    };
+}
+function taskDetail(task, labels = []) {
+    return {
+        ...taskSummary(task, labels),
+        prompt: task.initial_prompt,
+        agent: task.agent,
+        permissionMode: task.permission_mode,
+        worktreeSource: task.worktree_source,
+        worktreeBranch: task.worktree_branch,
+        titleSource: task.title_source,
+        titleGeneratedAt: task.title_generated_at,
+    };
+}
+function asciiLowercase(value) {
+    return value.replace(/[A-Z]/gu, character => character.toLowerCase());
+}
+function compareCompletedTasks(left, right) {
+    if (left.updated_at !== right.updated_at)
+        return right.updated_at - left.updated_at;
+    if (left.id === right.id)
+        return 0;
+    return left.id > right.id ? -1 : 1;
+}
+function testingCompletedTaskScope(projectId, query) {
+    return {
+        projectId,
+        search: asciiLowercase(query.search?.trim() ?? ''),
+        labels: [...new Set((query.labels ?? [])
+                .map(name => name.trim().toLowerCase())
+                .filter(Boolean))].sort(),
+    };
+}
+function encodeTestingCompletedTaskCursor(cursor) {
+    return `testing:${encodeURIComponent(JSON.stringify(cursor))}`;
+}
+function decodeTestingCompletedTaskCursor(encoded, scope) {
+    try {
+        if (!encoded.startsWith('testing:'))
+            throw new Error('wrong cursor format');
+        const cursor = JSON.parse(decodeURIComponent(encoded.slice('testing:'.length)));
+        if (cursor.version !== 1
+            || !Number.isSafeInteger(cursor.updatedAt)
+            || typeof cursor.id !== 'string'
+            || JSON.stringify(cursor.scope) !== JSON.stringify(scope)) {
+            throw new Error('invalid cursor payload');
+        }
+        return cursor;
+    }
+    catch {
+        throw new Error('Invalid Task cursor');
+    }
+}
+function listTestingCompletedTasks(allTasks, projectId, query = {}, labelsByTaskId = new Map()) {
+    if (!projectId.trim())
+        throw new RangeError('projectId is required');
+    const submittedLabels = query.labels ?? [];
+    if (submittedLabels.length > 20) {
+        throw new RangeError('Completed Task reads support at most 20 Task Label filters');
+    }
+    if (submittedLabels.some(name => [...name.trim()].length > 40)) {
+        throw new RangeError('Completed Task Label filters must be 40 characters or fewer');
+    }
+    if ([...(query.search?.trim() ?? '')].length > 200) {
+        throw new RangeError('Completed Task search must be 200 characters or fewer');
+    }
+    const scope = testingCompletedTaskScope(projectId, query);
+    const labels = new Set(scope.labels);
+    const cursor = query.cursor ? decodeTestingCompletedTaskCursor(query.cursor, scope) : null;
+    const matching = allTasks
+        .filter(task => task.status === 'done' && task.project_id === projectId)
+        .filter(task => {
+        const summary = taskSummary(task, labelsByTaskId.get(task.id));
+        return !scope.search || [summary.id, summary.title, summary.promptPreview]
+            .some(value => asciiLowercase(value).includes(scope.search));
+    })
+        .filter(task => {
+        if (labels.size === 0)
+            return true;
+        const names = taskSummary(task, labelsByTaskId.get(task.id))
+            .labels.map(label => label.name.toLowerCase());
+        return [...labels].every(label => names.includes(label));
+    })
+        .sort(compareCompletedTasks);
+    const remaining = cursor
+        ? matching.filter(task => task.updated_at < cursor.updatedAt
+            || (task.updated_at === cursor.updatedAt && task.id < cursor.id))
+        : matching;
+    const pageTasks = remaining.slice(0, 50);
+    const tasks = pageTasks.map(task => taskSummary(task, labelsByTaskId.get(task.id)));
+    const last = pageTasks.at(-1);
+    const nextCursor = remaining.length > 50 && last
+        ? encodeTestingCompletedTaskCursor({
+            version: 1,
+            scope,
+            updatedAt: last.updated_at,
+            id: last.id,
+        })
+        : null;
+    return { tasks, nextCursor };
+}
 export class TestingCommonApiFake {
     services;
     commands = new Map();
     eventListeners = new Map();
     eventHandlers = new Map();
+    taskChangeHandlers = new Map();
     eventListenerSequence = 0;
     constructor(services) {
         this.services = services;
     }
+    emitTaskChange(event) {
+        for (const handler of this.taskChangeHandlers.get(event.projectId) ?? []) {
+            handler(event);
+        }
+    }
     createApi() {
         const api = {
             commands: {
@@ -205,6 +395,16 @@ export class TestingCommonApiFake {
                 },
             },
             tasks: {
+                onDidChange: (projectId, handler) => {
+                    const handlers = this.taskChangeHandlers.get(projectId) ?? new Set();
+                    handlers.add(handler);
+                    this.taskChangeHandlers.set(projectId, handlers);
+                    return createDisposable(() => {
+                        handlers.delete(handler);
+                        if (handlers.size === 0)
+                            this.taskChangeHandlers.delete(projectId);
+                    });
+                },
                 list: async (request) => {
                     const projectId = request?.projectId ?? null;
                     const includeDone = request?.includeDone ?? false;
@@ -212,12 +412,54 @@ export class TestingCommonApiFake {
                     return this.services.seededTasks.filter((task) => {
                         if (projectId !== null && task.project_id !== projectId)
                             return false;
-                        if (!includeDone && task.status === 'done')
+                        if (projectId !== null && !includeDone && task.status === 'done')
                             return false;
                         return true;
                     });
                 },
-                get: async () => null,
+                get: async (taskId) => this.services.seededTasks.find(task => task.id === taskId) ?? null,
+                active: async (projectId) => {
+                    this.services.calls.taskActiveRequests.push({ projectId });
+                    const activeTasks = this.services.seededTasks.filter(task => task.project_id === projectId && task.status !== 'done');
+                    const activeIds = new Set(activeTasks.map(task => task.id));
+                    const relatedIds = new Set();
+                    for (const task of this.services.seededTasks) {
+                        if (activeIds.has(task.id)) {
+                            for (const dependencyId of task.depends_on)
+                                relatedIds.add(dependencyId);
+                        }
+                        else if (task.depends_on.some(dependencyId => activeIds.has(dependencyId))) {
+                            relatedIds.add(task.id);
+                        }
+                    }
+                    return {
+                        tasks: activeTasks.map(task => taskDetail(task, this.services.seededTaskLabelAssignments.get(task.id))),
+                        related: this.services.seededTasks
+                            .filter(task => relatedIds.has(task.id) && !activeIds.has(task.id))
+                            .map(taskReference),
+                    };
+                },
+                completed: async (projectId, query = {}) => {
+                    this.services.calls.taskCompletedRequests.push({ projectId, ...query });
+                    return listTestingCompletedTasks(this.services.seededTasks, projectId, query, this.services.seededTaskLabelAssignments);
+                },
+                detail: async (projectId, taskId) => {
+                    this.services.calls.taskDetailRequests.push({ projectId, taskId });
+                    const task = this.services.seededTasks.find(candidate => candidate.id === taskId && candidate.project_id === projectId);
+                    if (!task)
+                        return null;
+                    const relatedIds = new Set(task.depends_on);
+                    for (const candidate of this.services.seededTasks) {
+                        if (candidate.depends_on.includes(taskId))
+                            relatedIds.add(candidate.id);
+                    }
+                    return {
+                        task: taskDetail(task, this.services.seededTaskLabelAssignments.get(task.id)),
+                        related: this.services.seededTasks
+                            .filter(candidate => relatedIds.has(candidate.id))
+                            .map(taskReference),
+                    };
+                },
                 create: async (request) => {
                     this.services.calls.taskCreations.push(request);
                     return {
@@ -301,7 +543,8 @@ export class TestingCommonApiFake {
             },
             fs: {
                 readDir: async () => [],
-                readFile: async () => ({ type: 'text', content: '', mimeType: null, size: 0 }),
+                readFile: async ({ path }) => this.services.projectFileContents[path]
+                    ?? { type: 'text', content: '', mimeType: null, size: 0 },
                 writeFile: async (request) => {
                     this.services.calls.fsWrites.push(request);
                 },
@@ -379,7 +622,7 @@ export class TestingCommonApiFake {
                 userData: {
                     readDir: async (request = {}) => {
                         this.services.calls.fsUserDataReadDirs.push(request);
-                        return [];
+                        return readTestingUserDataDir(this.services.userDataTextFiles, request.path);
                     },
                     readTextFile: async (request) => {
                         this.services.calls.fsUserDataReads.push(request);