taphound 0.2.0-dev.1

package/dist/cli/commands/record.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliDependencies } from "../dependencies.js";
+export declare function createRecordCommand(dependencies: CliDependencies): Command;

package/dist/cli/commands/record.js

@@ -0,0 +1,88 @@
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { TapHoundConfigSchema } from "../../domain/config.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+export function createRecordCommand(dependencies) {
+    return new Command("record")
+        .description("Interactively record a TapHound Journey")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--config <path>", "TapHound config path", "taphound.config.json")
+        .option("--device <serial>", "Select an online Android device")
+        .requiredOption("--name <name>", "Journey name")
+        .requiredOption("--output <path>", "Journey output path")
+        .option("--json", "Emit machine-readable JSON")
+        .action(async (options) => {
+        let config;
+        try {
+            config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
+        }
+        catch (error) {
+            const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(2);
+            return;
+        }
+        try {
+            const doctor = await dependencies.doctor.run({
+                packageName: config.run.packageName,
+                ...(options.device === undefined
+                    ? {}
+                    : { requestedDevice: options.device }),
+                ...(dependencies.signal === undefined
+                    ? {}
+                    : { signal: dependencies.signal })
+            });
+            if (doctor.status === "failed") {
+                const output = failureOutput(3, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
+                    ?? "TapHound environment preflight failed");
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, output);
+                }
+                else {
+                    writeLine(dependencies.stderr, output.failure.message);
+                }
+                dependencies.setExitCode(3);
+                return;
+            }
+            const deviceSerial = options.device ?? doctor.deviceSerial;
+            if (deviceSerial === undefined) {
+                throw new Error("Doctor did not select a device");
+            }
+            const result = await dependencies.recorder.record({
+                config,
+                projectRoot: options.project,
+                deviceSerial,
+                journeyName: options.name,
+                outputPath: resolve(options.project, options.output),
+                ...(dependencies.signal === undefined
+                    ? {}
+                    : { signal: dependencies.signal })
+            });
+            if (options.json === true) {
+                writeJson(dependencies.stdout, result);
+            }
+            else if (result.status === "completed") {
+                writeLine(dependencies.stdout, `Recorded ${String(result.stepsRecorded)} step${result.stepsRecorded === 1 ? "" : "s"}`);
+            }
+            else {
+                writeLine(dependencies.stderr, result.status === "failed" ? result.message : "Recording cancelled");
+            }
+            dependencies.setExitCode(result.status === "failed" ? 1 : 0);
+        }
+        catch (error) {
+            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(4);
+        }
+    });
+}

package/dist/cli/commands/verify.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliDependencies } from "../dependencies.js";
+export declare function createVerifyCommand(dependencies: CliDependencies): Command;

package/dist/cli/commands/verify.js

@@ -0,0 +1,106 @@
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { TapHoundConfigSchema } from "../../domain/config.js";
+import { JourneySchema } from "../../domain/journey.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+function toolVersions(checks) {
+    return Object.fromEntries(checks.flatMap((check) => (check.version === undefined
+        || !["node", "adb", "android"].includes(check.name)
+        ? []
+        : [[check.name, check.version]])));
+}
+export function createVerifyCommand(dependencies) {
+    return new Command("verify")
+        .description("Deterministically verify a TapHound Journey")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--config <path>", "TapHound config path", "taphound.config.json")
+        .requiredOption("--journey <path>", "TapHound Journey path")
+        .option("--device <serial>", "Select an online Android device")
+        .option("--package <name>", "Override run.packageName")
+        .option("--activity <name>", "Override run.activity")
+        .option("--reports <path>", "Override report output directory")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        let config;
+        let journey;
+        try {
+            const rawConfig = await dependencies.readJson(resolve(options.project, options.config));
+            const parsed = TapHoundConfigSchema.parse(rawConfig);
+            config = TapHoundConfigSchema.parse({
+                ...parsed,
+                run: {
+                    packageName: options.package ?? parsed.run.packageName,
+                    activity: options.activity ?? parsed.run.activity
+                },
+                artifactsDir: options.reports ?? parsed.artifactsDir
+            });
+            journey = JourneySchema.parse(await dependencies.readJson(resolve(options.project, options.journey)));
+        }
+        catch (error) {
+            const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(2);
+            return;
+        }
+        try {
+            const doctor = await dependencies.doctor.run({
+                packageName: config.run.packageName,
+                ...(options.device === undefined
+                    ? {}
+                    : { requestedDevice: options.device }),
+                ...(dependencies.signal === undefined
+                    ? {}
+                    : { signal: dependencies.signal })
+            });
+            if (doctor.status === "failed") {
+                const output = failureOutput(3, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
+                    ?? "TapHound environment preflight failed");
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, output);
+                }
+                else {
+                    writeLine(dependencies.stderr, output.failure.message);
+                }
+                dependencies.setExitCode(3);
+                return;
+            }
+            const deviceSerial = options.device ?? doctor.deviceSerial;
+            if (deviceSerial === undefined) {
+                throw new Error("Doctor did not select a device");
+            }
+            writeLine(dependencies.stderr, `TapHound: verifying ${journey.name}`);
+            const result = await dependencies.verifier.verify({
+                config,
+                journey,
+                projectRoot: options.project,
+                deviceSerial,
+                toolVersions: toolVersions(doctor.checks),
+                ...(dependencies.signal === undefined
+                    ? {}
+                    : { signal: dependencies.signal })
+            });
+            if (options.json === true) {
+                writeJson(dependencies.stdout, result);
+            }
+            else {
+                writeLine(dependencies.stdout, `TapHound verify: ${result.status.toUpperCase()}\nReport: ${result.reportPath}`);
+            }
+            dependencies.setExitCode(result.exitCode);
+        }
+        catch (error) {
+            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(4);
+        }
+    });
+}

package/dist/cli/dependencies.d.ts

@@ -0,0 +1,66 @@
+import { ContextValidator } from "../application/context/context-validator.js";
+import type { DoctorReport, DoctorRunInput } from "../application/doctor/doctor-service.js";
+import { GenerationConfirmationService } from "../application/generation/generation-confirmation-service.js";
+import { GenerationFinalizer } from "../application/generation/generation-finalizer.js";
+import { GenerationStarter, type GenerationStartInput } from "../application/generation/generation-starter.js";
+import { GenerationStepExecutor } from "../application/generation/generation-step-executor.js";
+import { RuntimeObserver, type RuntimeObservation, type RuntimeObserveInput } from "../application/generation/runtime-observer.js";
+import { type InitInput } from "../application/init/init-service.js";
+import { ProjectDescriber } from "../application/project/project-describer.js";
+import { type RecordInput, type RecordResult } from "../application/recorder/recorder-service.js";
+import { type VerifyInput, type VerifyResult } from "../application/runtime/verify-runtime.js";
+import type { TapHoundConfig } from "../domain/config.js";
+import type { InitResult } from "../domain/init.js";
+import type { GenerationSession } from "../domain/generation.js";
+import type { InitPromptPort } from "../ports/init-prompt.js";
+import type { GenerationSessionStore } from "../ports/generation-session-store.js";
+export interface TextOutput {
+    write: (content: string) => void;
+}
+export interface GenerationCliRuntime {
+    confirmation: Pick<GenerationConfirmationService, "request" | "requestManual" | "confirmStored" | "findPendingManual">;
+    executor: Pick<GenerationStepExecutor, "execute">;
+    observer: Pick<RuntimeObserver, "observe">;
+    finalizer: Pick<GenerationFinalizer, "finalize">;
+    readSession: (id: string) => Promise<GenerationSession>;
+    assertConfigIdentity: (id: string) => Promise<void>;
+}
+export interface CliDependencies {
+    signal?: AbortSignal | undefined;
+    doctor: {
+        run: (input?: DoctorRunInput) => Promise<DoctorReport>;
+    };
+    recorder: {
+        record: (input: RecordInput) => Promise<RecordResult>;
+    };
+    verifier: {
+        verify: (input: VerifyInput) => Promise<VerifyResult>;
+    };
+    projectDescriber: Pick<ProjectDescriber, "describe">;
+    contextValidator: Pick<ContextValidator, "validate">;
+    generationStarter: {
+        start: (input: GenerationStartInput) => Promise<Awaited<ReturnType<GenerationStarter["start"]>>>;
+    };
+    runtimeObserver: {
+        observe: (input: RuntimeObserveInput & {
+            projectRoot: string;
+        }) => Promise<RuntimeObservation>;
+    };
+    generationRuntime?: (input: {
+        projectRoot: string;
+        config: TapHoundConfig;
+    }) => GenerationCliRuntime;
+    init: {
+        install: (input: InitInput) => Promise<InitResult>;
+    };
+    initPrompt: Pick<InitPromptPort, "selectAgents">;
+    readJson: (path: string) => Promise<unknown>;
+    cwd: () => string;
+    stdout: TextOutput;
+    stderr: TextOutput;
+    setExitCode: (code: number) => void;
+}
+export interface ProductionDependencyOptions {
+    generationStoreFactory?: (projectRoot: string) => GenerationSessionStore;
+}
+export declare function createProductionDependencies(signal?: AbortSignal, options?: ProductionDependencyOptions): CliDependencies;

package/dist/cli/dependencies.js

@@ -0,0 +1,204 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { AdbAdapter } from "../adapters/adb/adb-adapter.js";
+import { AndroidCliAdapter } from "../adapters/android-cli/android-cli-adapter.js";
+import { SystemClock } from "../adapters/clock/system-clock.js";
+import { FileSystemArtifactStore } from "../adapters/filesystem/artifact-store.js";
+import { FileSystemGenerationMetaWriter } from "../adapters/filesystem/generation-meta-writer.js";
+import { FileSystemGenerationSessionStore } from "../adapters/filesystem/generation-session-store.js";
+import { FileSystemJourneyWriter } from "../adapters/filesystem/journey-writer.js";
+import { NodeProjectFileInspector } from "../adapters/filesystem/project-file-inspector.js";
+import { FileSystemSkillInstaller } from "../adapters/filesystem/skill-installer.js";
+import { NodeProcessRunner } from "../adapters/process/node-process-runner.js";
+import { InquirerRecorderPrompt } from "../adapters/prompt/inquirer-recorder-prompt.js";
+import { InquirerGenerationPrompt } from "../adapters/prompt/inquirer-generation-prompt.js";
+import { InquirerInitPrompt } from "../adapters/prompt/inquirer-init-prompt.js";
+import { ContextValidator } from "../application/context/context-validator.js";
+import { DoctorService } from "../application/doctor/doctor-service.js";
+import { GenerationConfirmationService } from "../application/generation/generation-confirmation-service.js";
+import { GenerationFinalizer } from "../application/generation/generation-finalizer.js";
+import { GenerationPublisher } from "../application/generation/generation-publisher.js";
+import { GenerationStarter, GenerationOperationError, hashGenerationBinding } from "../application/generation/generation-starter.js";
+import { GenerationStepExecutor } from "../application/generation/generation-step-executor.js";
+import { RuntimeObserver, SnapshotReobservationGuard } from "../application/generation/runtime-observer.js";
+import { InitService } from "../application/init/init-service.js";
+import { ProjectDescriber } from "../application/project/project-describer.js";
+import { RecorderService } from "../application/recorder/recorder-service.js";
+import { ReportWriter } from "../application/report/report-writer.js";
+import { VerifyRuntime } from "../application/runtime/verify-runtime.js";
+function runId() {
+    return `${new Date().toISOString().replaceAll(":", "-")}-${randomUUID()}`;
+}
+export function createProductionDependencies(signal, options = {}) {
+    const runner = new NodeProcessRunner();
+    const adb = new AdbAdapter(runner);
+    const androidCli = new AndroidCliAdapter(runner);
+    const clock = new SystemClock();
+    const generationStoreFactory = options.generationStoreFactory
+        ?? ((projectRoot) => (new FileSystemGenerationSessionStore(projectRoot)));
+    const contextValidator = new ContextValidator(new NodeProjectFileInspector());
+    return {
+        ...(signal === undefined ? {} : { signal }),
+        doctor: new DoctorService({
+            runner,
+            adb,
+            nodeVersion: process.version,
+            checkAndroidPermissions: async (deviceSerial, signal) => {
+                const directory = await mkdtemp(join(tmpdir(), "taphound-doctor-"));
+                try {
+                    const result = await androidCli.captureScreen({
+                        outputPath: join(directory, "screen.png"),
+                        deviceSerial,
+                        ...(signal === undefined ? {} : { signal })
+                    });
+                    if (result.exitCode !== 0
+                        || result.spawnError !== undefined
+                        || result.cancelled
+                        || result.timedOut) {
+                        return {
+                            status: "failed",
+                            message: result.stderr.trim()
+                                || result.spawnError
+                                || "Android screen capture permission probe failed"
+                        };
+                    }
+                    return { status: "passed" };
+                }
+                finally {
+                    await rm(directory, { recursive: true, force: true });
+                }
+            }
+        }),
+        recorder: new RecorderService({
+            androidCli,
+            adb,
+            clock,
+            prompt: new InquirerRecorderPrompt(),
+            journeyWriter: new FileSystemJourneyWriter()
+        }),
+        verifier: new VerifyRuntime({
+            androidCli,
+            adb,
+            clock,
+            artifactStore: new FileSystemArtifactStore(),
+            reportWriter: new ReportWriter(),
+            now: () => new Date(),
+            createRunId: runId
+        }),
+        projectDescriber: new ProjectDescriber(),
+        contextValidator,
+        init: new InitService({
+            installer: new FileSystemSkillInstaller(),
+            cwd: process.cwd(),
+            homedir: homedir()
+        }),
+        initPrompt: new InquirerInitPrompt(),
+        generationStarter: {
+            start: async (input) => new GenerationStarter({
+                contextValidator,
+                store: generationStoreFactory(input.projectRoot),
+                now: () => new Date(),
+                generateId: randomUUID,
+                randomBytes
+            }).start(input)
+        },
+        runtimeObserver: {
+            observe: async ({ projectRoot, ...input }) => (new RuntimeObserver({
+                store: generationStoreFactory(projectRoot),
+                adb,
+                androidCli,
+                now: () => new Date(),
+                createAttemptId: randomUUID
+            }).observe(input))
+        },
+        generationRuntime: ({ projectRoot, config }) => {
+            const store = generationStoreFactory(projectRoot);
+            const prompt = new InquirerGenerationPrompt();
+            const observer = new RuntimeObserver({
+                store,
+                adb,
+                androidCli,
+                now: () => new Date(),
+                createAttemptId: randomUUID
+            });
+            const freshnessGuard = new SnapshotReobservationGuard({
+                store,
+                adb,
+                androidCli,
+                now: () => new Date()
+            });
+            const confirmation = new GenerationConfirmationService({
+                store,
+                prompt,
+                now: () => new Date(),
+                generateChallengeId: randomUUID,
+                confirmationTtlMs: 5 * 60_000
+            });
+            const executor = new GenerationStepExecutor({
+                store,
+                freshnessGuard,
+                adb,
+                androidCli,
+                clock,
+                idle: config.idle,
+                now: () => new Date(),
+                generateAttemptId: randomUUID,
+                clearApprovedConfirmation: async (generationId, challenge) => confirmation.clearApproved({
+                    generationId,
+                    challenge
+                })
+            });
+            const publisher = new GenerationPublisher({
+                store,
+                journeyWriter: new FileSystemJourneyWriter(),
+                metaWriter: new FileSystemGenerationMetaWriter()
+            });
+            const finalizer = new GenerationFinalizer({
+                store,
+                contextValidator,
+                adb,
+                verifyRuntime: new VerifyRuntime({
+                    androidCli,
+                    adb,
+                    clock,
+                    artifactStore: new FileSystemArtifactStore(),
+                    reportWriter: new ReportWriter(),
+                    now: () => new Date(),
+                    createRunId: runId
+                }),
+                publisher,
+                generateAttemptId: randomUUID
+            });
+            return {
+                confirmation,
+                executor,
+                observer,
+                finalizer,
+                readSession: (id) => store.read(id),
+                assertConfigIdentity: async (id) => {
+                    const session = await store.read(id);
+                    if (hashGenerationBinding(config) !== session.bindings.configHash) {
+                        throw new GenerationOperationError("CONFIG_INVALID", "Generation configuration does not match the authoritative session");
+                    }
+                }
+            };
+        },
+        readJson: async (path) => JSON.parse(await readFile(path, "utf8")),
+        cwd: () => process.cwd(),
+        stdout: {
+            write: (content) => {
+                process.stdout.write(content);
+            }
+        },
+        stderr: {
+            write: (content) => {
+                process.stderr.write(content);
+            }
+        },
+        setExitCode: (code) => {
+            process.exitCode = code;
+        }
+    };
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { type CliDependencies } from "./dependencies.js";
+export interface TerminationSignalSource {
+    once: (event: "SIGINT" | "SIGTERM", listener: () => void) => unknown;
+    off: (event: "SIGINT" | "SIGTERM", listener: () => void) => unknown;
+}
+export declare function withTerminationSignal<T>(operation: (signal: AbortSignal) => Promise<T>, source?: TerminationSignalSource): Promise<T>;
+export declare function runMain(argv: readonly string[], dependencies?: CliDependencies): Promise<void>;

package/dist/cli/main.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { CommanderError } from "commander";
+import { createProductionDependencies } from "./dependencies.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "./output.js";
+import { createProgram } from "./program.js";
+export async function withTerminationSignal(operation, source = process) {
+    const controller = new AbortController();
+    const abort = () => {
+        controller.abort(new Error("TapHound was interrupted"));
+    };
+    source.once("SIGINT", abort);
+    source.once("SIGTERM", abort);
+    try {
+        return await operation(controller.signal);
+    }
+    finally {
+        source.off("SIGINT", abort);
+        source.off("SIGTERM", abort);
+    }
+}
+function asCommanderFailure(error) {
+    if (error instanceof CommanderError) {
+        return error;
+    }
+    if (error === null || typeof error !== "object") {
+        return undefined;
+    }
+    const candidate = error;
+    return typeof candidate.exitCode === "number"
+        && typeof candidate.code === "string"
+        && candidate.code.startsWith("commander.")
+        ? { exitCode: candidate.exitCode }
+        : undefined;
+}
+function overrideCommandExits(command) {
+    command.exitOverride();
+    for (const child of command.commands) {
+        overrideCommandExits(child);
+    }
+}
+export async function runMain(argv, dependencies = createProductionDependencies()) {
+    const json = argv.includes("--json");
+    try {
+        const program = createProgram(dependencies);
+        overrideCommandExits(program);
+        await program.parseAsync([...argv]);
+    }
+    catch (error) {
+        const commander = asCommanderFailure(error);
+        if (commander?.exitCode === 0) {
+            dependencies.setExitCode(0);
+            return;
+        }
+        const commanderFailure = commander !== undefined;
+        const exitCode = commanderFailure ? 2 : 4;
+        const output = failureOutput(exitCode, commanderFailure ? "CONFIG_INVALID" : "INTERNAL_ERROR", errorMessage(error));
+        if (json) {
+            writeJson(dependencies.stdout, output);
+        }
+        else {
+            writeLine(dependencies.stderr, output.failure.message);
+        }
+        dependencies.setExitCode(exitCode);
+    }
+}
+const entryPath = process.argv[1];
+if (entryPath !== undefined
+    && import.meta.url === pathToFileURL(realpathSync(resolve(entryPath))).href) {
+    await withTerminationSignal((signal) => runMain(process.argv, createProductionDependencies(signal)));
+}

package/dist/cli/output.d.ts

@@ -0,0 +1,16 @@
+import type { DoctorReport } from "../application/doctor/doctor-service.js";
+import type { FailureCode } from "../domain/failure.js";
+import type { TextOutput } from "./dependencies.js";
+export interface CliFailureOutput {
+    status: "error";
+    exitCode: 2 | 3 | 4;
+    failure: {
+        code: FailureCode;
+        message: string;
+    };
+}
+export declare function writeJson(output: TextOutput, value: unknown): void;
+export declare function writeLine(output: TextOutput, value: string): void;
+export declare function failureOutput(exitCode: 2 | 3 | 4, code: FailureCode, message: string): CliFailureOutput;
+export declare function doctorMessage(report: DoctorReport): string;
+export declare function errorMessage(error: unknown): string;

package/dist/cli/output.js

@@ -0,0 +1,22 @@
+export function writeJson(output, value) {
+    output.write(`${JSON.stringify(value)}\n`);
+}
+export function writeLine(output, value) {
+    output.write(`${value}\n`);
+}
+export function failureOutput(exitCode, code, message) {
+    return {
+        status: "error",
+        exitCode,
+        failure: { code, message }
+    };
+}
+export function doctorMessage(report) {
+    return report.checks.map((check) => {
+        const detail = check.version ?? check.message;
+        return `${check.status === "passed" ? "✓" : "✗"} ${check.name}${detail === undefined ? "" : `: ${detail}`}`;
+    }).join("\n");
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/cli/program.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import { type CliDependencies } from "./dependencies.js";
+export declare function createProgram(dependencies?: CliDependencies): Command;

package/dist/cli/program.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import { createContextCommand } from "./commands/context.js";
+import { createDoctorCommand } from "./commands/doctor.js";
+import { createGenerationCommand } from "./commands/generation.js";
+import { createInitCommand } from "./commands/init.js";
+import { createProjectCommand } from "./commands/project.js";
+import { createRecordCommand } from "./commands/record.js";
+import { createVerifyCommand } from "./commands/verify.js";
+import { createProductionDependencies } from "./dependencies.js";
+export function createProgram(dependencies = createProductionDependencies()) {
+    const configureOutput = (command) => {
+        command.configureOutput({
+            writeOut: (content) => {
+                dependencies.stdout.write(content);
+            },
+            writeErr: (content) => {
+                dependencies.stderr.write(content);
+            }
+        });
+        for (const child of command.commands) {
+            configureOutput(child);
+        }
+        return command;
+    };
+    return new Command()
+        .name("taphound")
+        .description("Deterministic app journey recording and verification")
+        .configureOutput({
+        writeOut: (content) => {
+            dependencies.stdout.write(content);
+        },
+        writeErr: (content) => {
+            dependencies.stderr.write(content);
+        }
+    })
+        .addCommand(configureOutput(createDoctorCommand(dependencies)))
+        .addCommand(configureOutput(createRecordCommand(dependencies)))
+        .addCommand(configureOutput(createVerifyCommand(dependencies)))
+        .addCommand(configureOutput(createProjectCommand(dependencies)))
+        .addCommand(configureOutput(createContextCommand(dependencies)))
+        .addCommand(configureOutput(createGenerationCommand(dependencies)))
+        .addCommand(configureOutput(createInitCommand(dependencies)));
+}

package/dist/domain/activity.d.ts

@@ -0,0 +1,7 @@
+export interface ForegroundComponent {
+    packageName: string;
+    activity: string;
+}
+export declare function normalizeActivity(packageName: string, activityOrComponent: string): string;
+export declare function parseObservedActivityComponent(component: string): ForegroundComponent;
+export declare function normalizeObservedActivityComponent(component: string): string;