pi-simple-background-tasks 0.0.0-stage → 0.1.0

package/src/core/config.ts

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { CONFIG_DIR_NAME, getAgentDir } from '@earendil-works/pi-coding-agent';
+
+/** Config file name this extension reads, following the PI extension-config pattern. */
+export const PI_BG_CONFIG_FILE_NAME = 'pi-background-tasks.json';
+
+export interface PiBackgroundConfig {
+  readonly tasksDir: string;
+}
+
+interface BackgroundTasksConfigFile {
+  readonly tasksDir?: string;
+}
+
+/** Default tasks directory: the PI agent directory plus `tasks`. */
+export function defaultTasksDir(agentDir: string = getAgentDir()): string {
+  return join(agentDir, 'tasks');
+}
+
+function configError(file: string, reason: string): never {
+  throw new Error(`pi_bg_config_invalid: ${file} ${reason}`);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readConfigFile(file: string): BackgroundTasksConfigFile | undefined {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
+    throw error;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    configError(
+      file,
+      `is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  if (!isRecord(parsed)) configError(file, 'must contain a JSON object');
+  const unknown = Object.keys(parsed).filter((key) => key !== 'tasksDir');
+  if (unknown.length > 0) configError(file, `contains unknown keys: ${unknown.join(', ')}`);
+  if (parsed.tasksDir !== undefined && typeof parsed.tasksDir !== 'string')
+    configError(file, 'has a non-string tasksDir');
+  return parsed as BackgroundTasksConfigFile;
+}
+
+function resolveTasksDir(raw: string, configFileDir: string): string {
+  const expanded = raw === '~' || raw.startsWith('~/') ? join(homedir(), raw.slice(1)) : raw;
+  return isAbsolute(expanded) ? expanded : resolve(configFileDir, expanded);
+}
+
+/**
+ * Resolve extension configuration following the PI extension-config pattern:
+ * the global file under `<agent-dir>/extensions/` plus a project file under
+ * `<cwd>/.pi/`; project keys override global keys. Absent keys keep their
+ * defaults.
+ */
+export function resolveBackgroundTasksConfig(
+  cwd: string,
+  agentDir: string = getAgentDir(),
+): PiBackgroundConfig {
+  const files: Array<{ file: string; dir: string }> = [
+    { file: join(agentDir, 'extensions', PI_BG_CONFIG_FILE_NAME), dir: agentDir },
+    { file: join(cwd, CONFIG_DIR_NAME, PI_BG_CONFIG_FILE_NAME), dir: cwd },
+  ];
+  let tasksDir: string | undefined;
+  for (const { file, dir } of files) {
+    const parsed = readConfigFile(file);
+    if (parsed === undefined) continue;
+    if (parsed.tasksDir !== undefined) tasksDir = resolveTasksDir(parsed.tasksDir, dir);
+  }
+  return Object.freeze({
+    tasksDir: tasksDir ?? defaultTasksDir(agentDir),
+  });
+}

package/src/core/durable-fs.ts

@@ -0,0 +1,545 @@
+import { randomBytes } from 'node:crypto';
+import { open as nodeOpen, rename as nodeRename, rm as nodeRm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+
+export type DurableData = Buffer | string;
+export type DurableWriteFlag = 'w' | 'wx';
+export type DurableOperation =
+  | 'open_file'
+  | 'write_file'
+  | 'sync_file'
+  | 'close_file'
+  | 'rename_file'
+  | 'remove_temp'
+  | 'open_directory'
+  | 'sync_directory'
+  | 'close_directory';
+
+export interface DurableFailure {
+  operation: DurableOperation;
+  path: string;
+  cause: unknown;
+}
+
+export interface DurableWritableHandle {
+  writeFile(data: DurableData): Promise<void>;
+  sync(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export interface DurableDirectoryHandle {
+  sync(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export interface DurableFileOperations {
+  platform: NodeJS.Platform;
+  openWritable(path: string, flag: DurableWriteFlag, mode?: number): Promise<DurableWritableHandle>;
+  openDirectory(path: string): Promise<DurableDirectoryHandle>;
+  rename(source: string, target: string): Promise<void>;
+  remove(path: string): Promise<void>;
+  temporaryPath(target: string): string;
+}
+
+export interface DurableWriteOptions {
+  readonly signal?: AbortSignal | undefined;
+}
+
+export interface DurableFileWriter {
+  write(path: string, data: DurableData, options?: DurableWriteOptions): Promise<void>;
+  replace(path: string, data: DurableData, options?: DurableWriteOptions): Promise<void>;
+}
+
+interface DurableErrorInput {
+  operation: DurableOperation;
+  path: string;
+  cause: unknown;
+  cleanupFailures: readonly DurableFailure[];
+  targetPath: string | undefined;
+  temporaryPath: string | undefined;
+  renameCompleted: boolean;
+}
+
+interface WritableSequenceResult {
+  primaryFailure: DurableFailure | undefined;
+  cleanupFailures: DurableFailure[];
+  cancelled: boolean;
+}
+
+interface RenameSequenceResult {
+  error: unknown | undefined;
+  cancelled: boolean;
+}
+
+export class DurableFileCancellationError extends Error {
+  readonly code = 'durable_file_cancelled';
+  readonly path: string;
+  readonly reason: unknown;
+  readonly cleanupFailures: readonly DurableFailure[];
+  readonly targetPath: string | undefined;
+  readonly temporaryPath: string | undefined;
+  readonly renameCompleted: boolean;
+
+  constructor(input: {
+    path: string;
+    reason: unknown;
+    cleanupFailures: readonly DurableFailure[];
+    targetPath: string | undefined;
+    temporaryPath: string | undefined;
+    renameCompleted: boolean;
+  }) {
+    const reasonText = describeCause(input.reason);
+    const cleanupText =
+      input.cleanupFailures.length === 0
+        ? ''
+        : ` Cleanup failures: ${input.cleanupFailures.map(formatFailureForMessage).join('; ')}`;
+    const commitText = input.renameCompleted
+      ? ` Replacement may already be visible at ${input.targetPath ?? input.path}.`
+      : '';
+    super(
+      `Durable file operation cancelled for ${input.path}: ${reasonText}.${commitText}${cleanupText}`,
+    );
+    this.name = 'DurableFileCancellationError';
+    this.path = input.path;
+    this.reason = input.reason;
+    this.cleanupFailures = [...input.cleanupFailures];
+    this.targetPath = input.targetPath;
+    this.temporaryPath = input.temporaryPath;
+    this.renameCompleted = input.renameCompleted;
+  }
+}
+
+export class DurableFileError extends Error {
+  readonly operation: DurableOperation;
+  readonly path: string;
+  readonly nativeCode: string | undefined;
+  readonly primaryCause: unknown;
+  readonly cleanupFailures: readonly DurableFailure[];
+  readonly targetPath: string | undefined;
+  readonly temporaryPath: string | undefined;
+  readonly renameCompleted: boolean;
+
+  constructor(input: {
+    operation: DurableOperation;
+    path: string;
+    cause: unknown;
+    cleanupFailures: readonly DurableFailure[];
+    targetPath: string | undefined;
+    temporaryPath: string | undefined;
+    renameCompleted: boolean;
+  }) {
+    super(formatDurableMessage(input));
+    this.name = 'DurableFileError';
+    this.operation = input.operation;
+    this.path = input.path;
+    this.nativeCode = nativeCodeForCause(input.cause);
+    this.primaryCause = input.cause;
+    this.cleanupFailures = [...input.cleanupFailures];
+    this.targetPath = input.targetPath;
+    this.temporaryPath = input.temporaryPath;
+    this.renameCompleted = input.renameCompleted;
+  }
+}
+
+function failure(operation: DurableOperation, path: string, cause: unknown): DurableFailure {
+  return { operation, path, cause };
+}
+
+function durableError(input: DurableErrorInput): DurableFileError {
+  return new DurableFileError(input);
+}
+
+function nativeCodeForCause(cause: unknown): string | undefined {
+  if (typeof cause !== 'object' || cause === null) return undefined;
+  const code = Reflect.get(cause, 'code');
+  return typeof code === 'string' ? code : undefined;
+}
+
+function describeCause(cause: unknown): string {
+  if (cause instanceof Error) {
+    const message = cause.message.length > 0 ? cause.message : String(cause);
+    return `${cause.name}: ${message}`;
+  }
+  return String(cause);
+}
+
+function formatFailureForMessage(entry: DurableFailure): string {
+  const code = nativeCodeForCause(entry.cause);
+  const codeText = code === undefined ? '' : ` (code ${code})`;
+  return `${entry.operation} ${entry.path}${codeText}: ${describeCause(entry.cause)}`;
+}
+
+function formatDurableMessage(input: DurableErrorInput): string {
+  const primary = formatFailureForMessage({
+    operation: input.operation,
+    path: input.path,
+    cause: input.cause,
+  });
+  const segments = [`Durable file operation failed: ${primary}`];
+  if (input.targetPath !== undefined) segments.push(`target: ${input.targetPath}`);
+  if (input.temporaryPath !== undefined) segments.push(`temporary: ${input.temporaryPath}`);
+  if (input.renameCompleted) {
+    const target = input.targetPath ?? input.path;
+    segments.push(`Replacement may already be visible at ${target}.`);
+  }
+  if (input.cleanupFailures.length > 0) {
+    const cleanupText = input.cleanupFailures.map(formatFailureForMessage).join('; ');
+    segments.push(`Cleanup failures: ${cleanupText}`);
+  }
+  return segments.join(' ');
+}
+
+async function writeSyncClose(
+  handle: DurableWritableHandle,
+  path: string,
+  data: DurableData,
+  signal?: AbortSignal,
+): Promise<WritableSequenceResult> {
+  const cleanupFailures: DurableFailure[] = [];
+  let primaryFailure: DurableFailure | undefined;
+  let cancelled = signal?.aborted === true;
+  if (!cancelled) {
+    try {
+      await handle.writeFile(data);
+    } catch (error) {
+      primaryFailure = failure('write_file', path, error);
+    }
+    cancelled = signal?.aborted === true;
+  }
+  if (primaryFailure === undefined && !cancelled) {
+    try {
+      await handle.sync();
+    } catch (error) {
+      primaryFailure = failure('sync_file', path, error);
+    }
+    cancelled = signal?.aborted === true;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    const closeFailure = failure('close_file', path, error);
+    if (primaryFailure === undefined) primaryFailure = closeFailure;
+    else cleanupFailures.push(closeFailure);
+  }
+  cancelled ||= signal?.aborted === true;
+  return { primaryFailure, cleanupFailures, cancelled };
+}
+
+async function syncCloseDirectory(
+  handle: DurableDirectoryHandle,
+  path: string,
+): Promise<WritableSequenceResult> {
+  const cleanupFailures: DurableFailure[] = [];
+  let primaryFailure: DurableFailure | undefined;
+  try {
+    await handle.sync();
+  } catch (error) {
+    primaryFailure = failure('sync_directory', path, error);
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    const closeFailure = failure('close_directory', path, error);
+    if (primaryFailure === undefined) primaryFailure = closeFailure;
+    else cleanupFailures.push(closeFailure);
+  }
+  return { primaryFailure, cleanupFailures, cancelled: false };
+}
+
+function cancellationReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new Error('operation aborted');
+}
+
+function throwCancellation(
+  signal: AbortSignal,
+  path: string,
+  cleanupFailures: readonly DurableFailure[],
+  targetPath: string | undefined,
+  temporaryPath: string | undefined,
+  renameCompleted: boolean,
+): never {
+  const reason = cancellationReason(signal);
+  if (cleanupFailures.length === 0 && !renameCompleted && reason instanceof Error) throw reason;
+  throw new DurableFileCancellationError({
+    path,
+    reason,
+    cleanupFailures,
+    targetPath,
+    temporaryPath,
+    renameCompleted,
+  });
+}
+
+function throwDurable(
+  primaryFailure: DurableFailure,
+  cleanupFailures: readonly DurableFailure[],
+  targetPath: string | undefined,
+  temporaryPath: string | undefined,
+  renameCompleted: boolean,
+): never {
+  throw durableError({
+    operation: primaryFailure.operation,
+    path: primaryFailure.path,
+    cause: primaryFailure.cause,
+    cleanupFailures,
+    targetPath,
+    temporaryPath,
+    renameCompleted,
+  });
+}
+
+async function removeTemporary(
+  operations: DurableFileOperations,
+  temporaryPath: string,
+  cleanupFailures: DurableFailure[],
+): Promise<void> {
+  try {
+    await operations.remove(temporaryPath);
+  } catch (error) {
+    cleanupFailures.push(failure('remove_temp', temporaryPath, error));
+  }
+}
+
+function isAborted(signal: AbortSignal | undefined): boolean {
+  return signal?.aborted === true;
+}
+
+async function writeWithOperations(
+  operations: DurableFileOperations,
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions,
+): Promise<void> {
+  const signal = options.signal;
+  if (signal !== undefined && isAborted(signal))
+    throwCancellation(signal, path, [], path, undefined, false);
+  let handle: DurableWritableHandle;
+  try {
+    handle = await operations.openWritable(path, 'w');
+  } catch (error) {
+    if (signal !== undefined && isAborted(signal))
+      throwCancellation(signal, path, [], path, undefined, false);
+    throwDurable(failure('open_file', path, error), [], path, undefined, false);
+  }
+  const result = await writeSyncClose(handle, path, data, signal);
+  if (result.primaryFailure !== undefined) {
+    throwDurable(result.primaryFailure, result.cleanupFailures, path, undefined, false);
+  }
+  if (result.cancelled && signal !== undefined) {
+    throwCancellation(signal, path, result.cleanupFailures, path, undefined, false);
+  }
+}
+
+async function syncDirectoryAfterRename(
+  operations: DurableFileOperations,
+  targetPath: string,
+  temporaryPath: string,
+): Promise<void> {
+  if (operations.platform === 'win32') return;
+  const directoryPath = dirname(targetPath);
+  let handle: DurableDirectoryHandle;
+  try {
+    handle = await operations.openDirectory(directoryPath);
+  } catch (error) {
+    throwDurable(
+      failure('open_directory', directoryPath, error),
+      [],
+      targetPath,
+      temporaryPath,
+      true,
+    );
+  }
+  const result = await syncCloseDirectory(handle, directoryPath);
+  if (result.primaryFailure !== undefined) {
+    throwDurable(result.primaryFailure, result.cleanupFailures, targetPath, temporaryPath, true);
+  }
+}
+
+async function replaceWithOperations(
+  operations: DurableFileOperations,
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions,
+): Promise<void> {
+  const signal = options.signal;
+  if (signal !== undefined && isAborted(signal))
+    throwCancellation(signal, path, [], path, undefined, false);
+  const temporaryPath = operations.temporaryPath(path);
+  let handle: DurableWritableHandle;
+  try {
+    handle = await operations.openWritable(temporaryPath, 'wx', 0o600);
+  } catch (error) {
+    if (signal !== undefined && isAborted(signal))
+      throwCancellation(signal, temporaryPath, [], path, temporaryPath, false);
+    throwDurable(failure('open_file', temporaryPath, error), [], path, temporaryPath, false);
+  }
+  const writeResult = await writeSyncClose(handle, temporaryPath, data, signal);
+  if (writeResult.primaryFailure !== undefined) {
+    await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
+    throwDurable(
+      writeResult.primaryFailure,
+      writeResult.cleanupFailures,
+      path,
+      temporaryPath,
+      false,
+    );
+  }
+  if (writeResult.cancelled && signal !== undefined) {
+    await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
+    throwCancellation(
+      signal,
+      temporaryPath,
+      writeResult.cleanupFailures,
+      path,
+      temporaryPath,
+      false,
+    );
+  }
+  const renameResult = await renameWithWindowsContention(operations, temporaryPath, path, signal);
+  if (renameResult.cancelled && signal !== undefined) {
+    const cleanupFailures: DurableFailure[] = [];
+    await removeTemporary(operations, temporaryPath, cleanupFailures);
+    throwCancellation(signal, temporaryPath, cleanupFailures, path, temporaryPath, false);
+  }
+  if (renameResult.error !== undefined) {
+    const cleanupFailures: DurableFailure[] = [];
+    await removeTemporary(operations, temporaryPath, cleanupFailures);
+    throwDurable(
+      failure('rename_file', path, renameResult.error),
+      cleanupFailures,
+      path,
+      temporaryPath,
+      false,
+    );
+  }
+  await syncDirectoryAfterRename(operations, path, temporaryPath);
+  if (signal !== undefined && isAborted(signal)) {
+    throwCancellation(signal, path, [], path, temporaryPath, true);
+  }
+}
+
+/**
+ * Windows sharing-violation codes for a replace-rename.
+ *
+ * POSIX `rename(2)` atomically replaces the target. Windows `MoveFileEx` fails
+ * with a sharing violation when another process momentarily holds the target
+ * open, including transient scanners, indexers, and concurrent writers. The
+ * operation is legitimate and simply needs to be reattempted.
+ */
+const WINDOWS_RENAME_CONTENTION_CODES: ReadonlySet<string> = new Set(['EPERM', 'EACCES', 'EBUSY']);
+
+const WINDOWS_RENAME_ATTEMPTS = 10;
+const WINDOWS_RENAME_RETRY_DELAY_MS = 20;
+
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  if (isAborted(signal)) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', aborted);
+      resolve();
+    }, ms);
+    const aborted = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal?.addEventListener('abort', aborted, { once: true });
+  });
+}
+
+/**
+ * Rename the temporary file over the target, retrying only Windows sharing
+ * violations.
+ *
+ * This is a bounded retry of a transient OS condition, not a fallback: the
+ * final failure is still returned and raised loudly, no alternative write path
+ * is taken, and no other platform or error code is retried.
+ *
+ * Returns an explicit success/error/cancellation sequence result.
+ */
+async function renameWithWindowsContention(
+  operations: DurableFileOperations,
+  temporaryPath: string,
+  targetPath: string,
+  signal?: AbortSignal,
+): Promise<RenameSequenceResult> {
+  const attempts = operations.platform === 'win32' ? WINDOWS_RENAME_ATTEMPTS : 1;
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (isAborted(signal)) return { error: undefined, cancelled: true };
+    try {
+      await operations.rename(temporaryPath, targetPath);
+      return { error: undefined, cancelled: false };
+    } catch (error) {
+      lastError = error;
+      if (isAborted(signal)) return { error: undefined, cancelled: true };
+      const code = nativeCodeForCause(error);
+      const retryable =
+        operations.platform === 'win32' &&
+        code !== undefined &&
+        WINDOWS_RENAME_CONTENTION_CODES.has(code);
+      if (!retryable || attempt === attempts) return { error, cancelled: false };
+      await delay(WINDOWS_RENAME_RETRY_DELAY_MS * attempt, signal);
+    }
+  }
+  return { error: lastError, cancelled: false };
+}
+
+function temporaryPathForTarget(target: string): string {
+  return join(
+    dirname(target),
+    `.${basename(target)}.${String(process.pid)}.${randomBytes(6).toString('hex')}.tmp`,
+  );
+}
+
+const nodeOperations: DurableFileOperations = {
+  platform: process.platform,
+  async openWritable(path: string, flag: DurableWriteFlag, mode?: number) {
+    if (mode === undefined) return nodeOpen(path, flag);
+    return nodeOpen(path, flag, mode);
+  },
+  async openDirectory(path: string) {
+    return nodeOpen(path, 'r');
+  },
+  async rename(source: string, target: string) {
+    await nodeRename(source, target);
+  },
+  async remove(path: string) {
+    // `force` ignores a missing path only. Permission and other failures still
+    // throw and are surfaced as `remove_temp` cleanup failures.
+    await nodeRm(path, { force: true });
+  },
+  temporaryPath: temporaryPathForTarget,
+};
+
+const defaultWriter = createDurableFileWriter(nodeOperations);
+
+export function createDurableFileWriter(operations: DurableFileOperations): DurableFileWriter {
+  return {
+    async write(path: string, data: DurableData, options: DurableWriteOptions = {}): Promise<void> {
+      await writeWithOperations(operations, path, data, options);
+    },
+    async replace(
+      path: string,
+      data: DurableData,
+      options: DurableWriteOptions = {},
+    ): Promise<void> {
+      await replaceWithOperations(operations, path, data, options);
+    },
+  };
+}
+
+export async function writeFileDurable(
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions = {},
+): Promise<void> {
+  await defaultWriter.write(path, data, options);
+}
+
+export async function replaceFileDurable(
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions = {},
+): Promise<void> {
+  await defaultWriter.replace(path, data, options);
+}

package/src/core/extension-api.ts

@@ -0,0 +1,70 @@
+import type { EventBus } from '@earendil-works/pi-coding-agent';
+import type { BgTaskSnapshot } from './common.js';
+import type { BackgroundTaskRegistry } from './registry.js';
+
+export const BG_TERMINAL_CHANNEL = 'pi-background-tasks:terminal:v1';
+export const BG_TERMINAL_SCHEMA = 'pi-background-tasks.extension-terminal.v1';
+export const BG_EXTENSION_SERVICE_CLOSED_CODE = 'pi_background_tasks_eventbus_closed';
+
+export type BackgroundTaskExtensionServiceState = 'open' | 'closed';
+
+export class BackgroundTaskExtensionServiceClosedError extends Error {
+  readonly code = BG_EXTENSION_SERVICE_CLOSED_CODE;
+
+  constructor() {
+    super('pi-background-tasks EventBus service is closed');
+    this.name = 'BackgroundTaskExtensionServiceClosedError';
+  }
+}
+
+export interface BackgroundTaskExtensionTerminal {
+  schema_version: typeof BG_TERMINAL_SCHEMA;
+  task: BgTaskSnapshot;
+}
+
+export interface BackgroundTaskExtensionService {
+  readonly state: BackgroundTaskExtensionServiceState;
+  publishTerminal(task: BgTaskSnapshot): void;
+  close(): void;
+}
+
+export interface BackgroundTaskExtensionServiceOptions {
+  events: EventBus;
+  registry: BackgroundTaskRegistry;
+}
+
+class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtensionService {
+  private readonly events: EventBus;
+  private readonly registry: BackgroundTaskRegistry;
+  private serviceState: BackgroundTaskExtensionServiceState = 'open';
+
+  constructor(options: BackgroundTaskExtensionServiceOptions) {
+    this.events = options.events;
+    this.registry = options.registry;
+  }
+
+  get state(): BackgroundTaskExtensionServiceState {
+    return this.serviceState;
+  }
+
+  publishTerminal(task: BgTaskSnapshot): void {
+    if (this.serviceState === 'closed') throw new BackgroundTaskExtensionServiceClosedError();
+    const terminal: BackgroundTaskExtensionTerminal = {
+      schema_version: BG_TERMINAL_SCHEMA,
+      task,
+    };
+    this.events.emit(BG_TERMINAL_CHANNEL, terminal);
+  }
+
+  close(): void {
+    if (this.serviceState === 'closed') return;
+    this.serviceState = 'closed';
+    this.registry.closeTerminalPublication('publisher_closed');
+  }
+}
+
+export function installBackgroundTaskExtensionApi(
+  options: BackgroundTaskExtensionServiceOptions,
+): BackgroundTaskExtensionService {
+  return new InstalledBackgroundTaskExtensionService(options);
+}