agentplane 0.3.13 → 0.3.15

package/dist/cli/run-cli.test-helpers.js

@@ -1,769 +1 @@
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { access, cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-import { gzipSync } from "node:zlib";
-import { afterAll, afterEach, beforeAll, beforeEach, expect, vi } from "vitest";
-import { defaultConfig } from "@agentplaneorg/core";
-import { runCli } from "./run-cli.js";
-const execFileAsync = promisify(execFile);
-let agentplaneHome = null;
-const testRoots = new Set();
-const originalAgentplaneHome = process.env.AGENTPLANE_HOME;
-const originalNoUpdateCheck = process.env.AGENTPLANE_NO_UPDATE_CHECK;
-const originalGitAuthorName = process.env.GIT_AUTHOR_NAME;
-const originalGitAuthorEmail = process.env.GIT_AUTHOR_EMAIL;
-const originalGitCommitterName = process.env.GIT_COMMITTER_NAME;
-const originalGitCommitterEmail = process.env.GIT_COMMITTER_EMAIL;
-const originalHookRunner = process.env.AGENTPLANE_HOOK_RUNNER;
-const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-const originalStderrWrite = process.stderr.write.bind(process.stderr);
-let stdioSilenceDepth = 0;
-const recipeArchiveCache = new Map();
-let gitTemplateRoot = null;
-let gitTemplatePromise = null;
-async function ensureGitTemplateRoot() {
-    if (gitTemplateRoot)
-        return gitTemplateRoot;
-    gitTemplatePromise ??= (async () => {
-        const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-git-template-"));
-        await execFileAsync("git", ["init", "-q"], { cwd: root, env: cleanGitEnv() });
-        // Tests must not rely on global git config. Configure author identity locally
-        // so any helper that creates commits works in CI.
-        await execFileAsync("git", ["config", "user.email", "agentplane-test@example.com"], {
-            cwd: root,
-            env: cleanGitEnv(),
-        });
-        await execFileAsync("git", ["config", "user.name", "agentplane-test"], {
-            cwd: root,
-            env: cleanGitEnv(),
-        });
-        return root;
-    })();
-    gitTemplateRoot = await gitTemplatePromise;
-    return gitTemplateRoot;
-}
-async function copyDirContents(src, dest) {
-    const entries = await readdir(src, { withFileTypes: true });
-    await Promise.all(entries.map((entry) => cp(path.join(src, entry.name), path.join(dest, entry.name), { recursive: true })));
-}
-export function registerAgentplaneHome() {
-    beforeAll(async () => {
-        agentplaneHome = await mkdtemp(path.join(os.tmpdir(), "agentplane-home-"));
-        process.env.AGENTPLANE_HOME = agentplaneHome;
-        process.env.AGENTPLANE_NO_UPDATE_CHECK = "1";
-        process.env.AGENTPLANE_HOOK_RUNNER ??= path.join(process.cwd(), "packages", "agentplane", "bin", "agentplane.js");
-        // Keep tests hermetic: never rely on global git config for commit authorship.
-        process.env.GIT_AUTHOR_NAME ??= "agentplane-test";
-        process.env.GIT_AUTHOR_EMAIL ??= "agentplane-test@example.com";
-        process.env.GIT_COMMITTER_NAME ??= "agentplane-test";
-        process.env.GIT_COMMITTER_EMAIL ??= "agentplane-test@example.com";
-    });
-    afterAll(async () => {
-        if (agentplaneHome) {
-            await rm(agentplaneHome, { recursive: true, force: true });
-        }
-        if (originalAgentplaneHome === undefined) {
-            delete process.env.AGENTPLANE_HOME;
-        }
-        else {
-            process.env.AGENTPLANE_HOME = originalAgentplaneHome;
-        }
-        if (originalNoUpdateCheck === undefined) {
-            delete process.env.AGENTPLANE_NO_UPDATE_CHECK;
-        }
-        else {
-            process.env.AGENTPLANE_NO_UPDATE_CHECK = originalNoUpdateCheck;
-        }
-        if (originalGitAuthorName === undefined)
-            delete process.env.GIT_AUTHOR_NAME;
-        else
-            process.env.GIT_AUTHOR_NAME = originalGitAuthorName;
-        if (originalGitAuthorEmail === undefined)
-            delete process.env.GIT_AUTHOR_EMAIL;
-        else
-            process.env.GIT_AUTHOR_EMAIL = originalGitAuthorEmail;
-        if (originalGitCommitterName === undefined)
-            delete process.env.GIT_COMMITTER_NAME;
-        else
-            process.env.GIT_COMMITTER_NAME = originalGitCommitterName;
-        if (originalGitCommitterEmail === undefined)
-            delete process.env.GIT_COMMITTER_EMAIL;
-        else
-            process.env.GIT_COMMITTER_EMAIL = originalGitCommitterEmail;
-        if (originalHookRunner === undefined)
-            delete process.env.AGENTPLANE_HOOK_RUNNER;
-        else
-            process.env.AGENTPLANE_HOOK_RUNNER = originalHookRunner;
-    });
-    afterEach(async () => {
-        const roots = [...testRoots];
-        testRoots.clear();
-        await Promise.all(roots.map(async (root) => {
-            await rm(path.join(root, ".agentplane", ".upgrade"), { recursive: true, force: true });
-            await rm(path.join(root, ".agentplane", ".release"), { recursive: true, force: true });
-        }));
-    });
-}
-export function installRunCliIntegrationHarness() {
-    registerAgentplaneHome();
-    let restoreStdIO = null;
-    beforeEach(() => {
-        restoreStdIO = silenceStdIO();
-    });
-    afterEach(() => {
-        restoreStdIO?.();
-        restoreStdIO = null;
-    });
-}
-export function getAgentplaneHome() {
-    return agentplaneHome;
-}
-export function captureStdIO() {
-    let stdout = "";
-    let stderr = "";
-    const origStdoutWrite = process.stdout.write.bind(process.stdout);
-    const origStderrWrite = process.stderr.write.bind(process.stderr);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    process.stdout.write = (chunk) => {
-        stdout += String(chunk);
-        return true;
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    process.stderr.write = (chunk) => {
-        stderr += String(chunk);
-        return true;
-    };
-    return {
-        get stdout() {
-            return stdout;
-        },
-        get stderr() {
-            return stderr;
-        },
-        restore() {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            process.stdout.write = origStdoutWrite;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            process.stderr.write = origStderrWrite;
-        },
-    };
-}
-export function splitOutputLines(text) {
-    return text
-        .trim()
-        .split(/\r?\n/)
-        .map((line) => line.trimEnd())
-        .filter(Boolean);
-}
-export function parseAgentJsonEnvelope(stdout) {
-    return JSON.parse(stdout);
-}
-export function expectAgentJsonEnvelope(payload, opts) {
-    expect(payload.schema_version).toBe(1);
-    expect(payload.mode).toBe("agent_json_v1");
-    expect(payload.command).toBe(opts.command);
-    expect(payload.ok).toBe(opts.ok);
-    expect(payload.exit_code).toBe(opts.exitCode);
-    expect(Object.keys(payload)).toEqual(opts.hasData
-        ? ["schema_version", "mode", "command", "ok", "exit_code", "stdout", "stderr", "data"]
-        : ["schema_version", "mode", "command", "ok", "exit_code", "stdout", "stderr"]);
-    expect(Object.hasOwn(payload, "data")).toBe(opts.hasData ?? false);
-}
-export function silenceStdIO() {
-    if (stdioSilenceDepth === 0) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        process.stdout.write = () => true;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        process.stderr.write = () => true;
-    }
-    stdioSilenceDepth += 1;
-    return () => {
-        stdioSilenceDepth -= 1;
-        if (stdioSilenceDepth <= 0) {
-            stdioSilenceDepth = 0;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            process.stdout.write = originalStdoutWrite;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            process.stderr.write = originalStderrWrite;
-        }
-    };
-}
-export function stubTaskBackend(overrides = {}) {
-    return {
-        id: "local",
-        capabilities: {
-            canonical_source: "local",
-            projection: "canonical",
-            projection_read_mode: "fallback",
-            reads_from_projection_by_default: false,
-            writes_task_readmes: true,
-            supports_task_revisions: true,
-            supports_revision_guarded_writes: true,
-            may_access_network_on_read: false,
-            may_access_network_on_write: false,
-            supports_projection_refresh: false,
-            supports_push_sync: false,
-            supports_snapshot_export: false,
-        },
-        listTasks: vi.fn().mockResolvedValue([]),
-        getTask: vi.fn().mockResolvedValue(null),
-        writeTask: vi.fn().mockImplementation(() => Promise.resolve()),
-        ...overrides,
-    };
-}
-export async function runCliSilent(args) {
-    const io = captureStdIO();
-    try {
-        return await runCli(args);
-    }
-    finally {
-        io.restore();
-    }
-}
-export async function mkGitRepoRoot() {
-    const template = await ensureGitTemplateRoot();
-    const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-cli-test-"));
-    await copyDirContents(template, root);
-    testRoots.add(root);
-    return root;
-}
-export async function mkTempDir() {
-    const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-cli-test-"));
-    testRoots.add(root);
-    return root;
-}
-export async function writeDefaultConfig(root) {
-    const agentplaneDir = path.join(root, ".agentplane");
-    await mkdir(agentplaneDir, { recursive: true });
-    const configPath = path.join(agentplaneDir, "config.json");
-    await writeFile(configPath, JSON.stringify(defaultConfig(), null, 2), "utf8");
-}
-export async function writeAndConfigureRoot() {
-    const root = await mkGitRepoRoot();
-    await writeDefaultConfig(root);
-    return root;
-}
-export async function approveTaskPlan(root, taskId) {
-    await runCliSilent([
-        "task",
-        "plan",
-        "set",
-        taskId,
-        "--text",
-        "1) Do the work\n2) Verify the work",
-        "--updated-by",
-        "ORCHESTRATOR",
-        "--root",
-        root,
-    ]);
-    await runCliSilent([
-        "task",
-        "plan",
-        "approve",
-        taskId,
-        "--by",
-        "USER",
-        "--note",
-        "OK",
-        "--root",
-        root,
-    ]);
-}
-export async function recordVerificationOk(root, taskId) {
-    await runCliSilent([
-        "task",
-        "doc",
-        "set",
-        taskId,
-        "--section",
-        "Verify Steps",
-        "--text",
-        "Run verify for this task. Expected: verification records successfully.",
-        "--root",
-        root,
-    ]);
-    await runCliSilent([
-        "verify",
-        taskId,
-        "--ok",
-        "--by",
-        "REVIEWER",
-        "--note",
-        "Ok to integrate",
-        "--quiet",
-        "--root",
-        root,
-    ]);
-}
-export async function writeConfig(root, config) {
-    const agentplaneDir = path.join(root, ".agentplane");
-    await mkdir(agentplaneDir, { recursive: true });
-    const configPath = path.join(agentplaneDir, "config.json");
-    await writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
-}
-export async function resetAgentplaneHomeRecipes() {
-    if (!agentplaneHome)
-        return;
-    await rm(path.join(agentplaneHome, "recipes-store"), { recursive: true, force: true });
-    await rm(path.join(agentplaneHome, "recipes.json"), { force: true });
-    await rm(path.join(agentplaneHome, "recipes-index.json"), { force: true });
-}
-export async function createRecipeArchive(opts) {
-    const normalizedTags = opts?.tags ? [...opts.tags].toSorted() : undefined;
-    const cacheKey = JSON.stringify({
-        id: opts?.id ?? "viewer",
-        version: opts?.version ?? "1.2.3",
-        name: opts?.name ?? "Viewer",
-        summary: opts?.summary ?? "Preview task artifacts",
-        description: opts?.description ?? "Provides a local viewer for task artifacts.",
-        tags: normalizedTags,
-        format: opts?.format ?? "tar",
-        wrapDir: opts?.wrapDir ?? false,
-    });
-    const cached = recipeArchiveCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const baseDir = await mkdtemp(path.join(os.tmpdir(), "agentplane-recipe-"));
-    const recipeDir = path.join(baseDir, opts?.wrapDir ? "bundle" : "recipe");
-    await mkdir(recipeDir, { recursive: true });
-    const manifest = {
-        schema_version: "1",
-        id: opts?.id ?? "viewer",
-        version: opts?.version ?? "1.2.3",
-        name: opts?.name ?? "Viewer",
-        summary: opts?.summary ?? "Preview task artifacts",
-        description: opts?.description ?? "Provides a local viewer for task artifacts.",
-        compatibility: {
-            min_agentplane_version: "0.3.5",
-            manifest_api_version: "1",
-            scenario_api_version: "1",
-            runtime_api_version: "1",
-            platforms: ["darwin", "linux"],
-            repo_types: ["generic"],
-        },
-        skills: [
-            {
-                id: "RECIPE_SKILL",
-                summary: "Recipe analysis skill",
-                file: "skills/analysis.md",
-            },
-        ],
-        agents: [
-            {
-                id: "RECIPE_AGENT",
-                display_name: "Recipe Agent",
-                role: "executor",
-                summary: "Recipe agent",
-                skills: ["RECIPE_SKILL"],
-                tools: ["RECIPE_TOOL"],
-                file: "agents/recipe.md",
-            },
-        ],
-        tools: [
-            { id: "RECIPE_TOOL", summary: "Recipe tool", runtime: "node", entrypoint: "tools/run.js" },
-        ],
-        scenarios: [
-            {
-                id: "RECIPE_SCENARIO",
-                name: "Recipe Scenario",
-                summary: "Recipe scenario",
-                use_when: ["Task artifacts need local preview"],
-                required_inputs: ["task_id"],
-                outputs: ["report"],
-                permissions: ["filesystem-write"],
-                artifacts: ["artifact.txt"],
-                agents_involved: ["RECIPE_AGENT"],
-                skills_used: ["RECIPE_SKILL"],
-                tools_used: ["RECIPE_TOOL"],
-                run_profile: {
-                    mode: "analysis",
-                    sandbox: "workspace-write",
-                    writes_artifacts_to: ["logs/", "reports/"],
-                },
-                file: "scenarios/recipe-scenario.json",
-            },
-        ],
-    };
-    if (normalizedTags) {
-        manifest.tags = normalizedTags;
-    }
-    await writeFile(path.join(recipeDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-    const agentsDir = path.join(recipeDir, "agents");
-    await mkdir(agentsDir, { recursive: true });
-    await writeFile(path.join(agentsDir, "recipe.md"), [
-        "# Recipe Agent",
-        "",
-        "Role: executor",
-        "",
-        "Instructions:",
-        "- Use recipe local policy.",
-        "- Materialize the declared scenario artifacts.",
-    ].join("\n"), "utf8");
-    const skillsDir = path.join(recipeDir, "skills");
-    await mkdir(skillsDir, { recursive: true });
-    await writeFile(path.join(skillsDir, "analysis.md"), [
-        "# Recipe Skill",
-        "",
-        "- Inspect the generated bundle before acting.",
-        "- Keep recipe-owned artifacts inside the declared output paths.",
-    ].join("\n"), "utf8");
-    const toolsDir = path.join(recipeDir, "tools");
-    await mkdir(toolsDir, { recursive: true });
-    await writeFile(path.join(toolsDir, "run.js"), [
-        'const fs = require("node:fs");',
-        'fs.writeFileSync(process.env.AGENTPLANE_RUN_DIR + "/artifact.txt", "ok");',
-    ].join("\n"), "utf8");
-    const scenariosDir = path.join(recipeDir, "scenarios");
-    await mkdir(scenariosDir, { recursive: true });
-    await writeFile(path.join(scenariosDir, "recipe-scenario.json"), JSON.stringify({
-        schema_version: "1",
-        id: "RECIPE_SCENARIO",
-        summary: "Recipe scenario",
-        goal: "Preview installed tasks.",
-        task_template: {
-            title: "Recipe scenario task",
-            description: "Materialize a task from the recipe scenario.",
-            owner: "CODER",
-            priority: "med",
-            tags: ["code", "recipes"],
-            verify: ["bunx vitest run packages/agentplane/src/cli/run-cli.scenario.test.ts"],
-            doc: {
-                summary: "Recipe-backed task execution.",
-                scope: "Run the scenario without task materialization heuristics.",
-                plan: "1. Materialize the task. 2. Execute the shared runner.",
-                verify_steps: "1. Run scenario execution tests.",
-                rollback_plan: "Revert the generated task and runner artifacts.",
-            },
-        },
-        inputs: [{ name: "task_id", type: "string" }],
-        outputs: [{ name: "report", type: "html" }],
-        steps: [{ tool: "RECIPE_TOOL" }],
-    }, null, 2), "utf8");
-    const format = opts?.format ?? "tar";
-    const archivePath = format === "zip" ? path.join(baseDir, "recipe.zip") : path.join(baseDir, "recipe.tar.gz");
-    if (format === "zip") {
-        await (opts?.wrapDir
-            ? execFileAsync("zip", ["-qr", archivePath, path.basename(recipeDir)], { cwd: baseDir })
-            : execFileAsync("zip", ["-qr", archivePath, "."], { cwd: recipeDir }));
-    }
-    else {
-        await (opts?.wrapDir
-            ? execFileAsync("tar", ["-czf", archivePath, "-C", baseDir, path.basename(recipeDir)])
-            : execFileAsync("tar", ["-czf", archivePath, "-C", recipeDir, "."]));
-    }
-    const payload = { archivePath, manifest };
-    recipeArchiveCache.set(cacheKey, payload);
-    return payload;
-}
-export async function createRecipeArchiveWithManifest(opts) {
-    const baseDir = await mkdtemp(path.join(os.tmpdir(), "agentplane-recipe-bad-"));
-    const recipeDir = path.join(baseDir, opts.wrapDir ? "bundle" : "recipe");
-    await mkdir(recipeDir, { recursive: true });
-    await writeFile(path.join(recipeDir, "manifest.json"), JSON.stringify(opts.manifest, null, 2));
-    if (opts.files) {
-        for (const [relPath, content] of Object.entries(opts.files)) {
-            const fullPath = path.join(recipeDir, relPath);
-            await mkdir(path.dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, content, "utf8");
-        }
-    }
-    const format = opts.format ?? "tar";
-    const archivePath = format === "zip" ? path.join(baseDir, "recipe.zip") : path.join(baseDir, "recipe.tar.gz");
-    if (format === "zip") {
-        await (opts.wrapDir
-            ? execFileAsync("zip", ["-qr", archivePath, path.basename(recipeDir)], { cwd: baseDir })
-            : execFileAsync("zip", ["-qr", archivePath, "."], { cwd: recipeDir }));
-    }
-    else {
-        await (opts.wrapDir
-            ? execFileAsync("tar", ["-czf", archivePath, "-C", baseDir, path.basename(recipeDir)])
-            : execFileAsync("tar", ["-czf", archivePath, "-C", recipeDir, "."]));
-    }
-    return archivePath;
-}
-export async function createUnsafeRecipeArchive(opts) {
-    const baseDir = await mkdtemp(path.join(os.tmpdir(), "agentplane-recipe-unsafe-"));
-    const recipeDir = path.join(baseDir, "recipe");
-    await mkdir(recipeDir, { recursive: true });
-    const manifest = {
-        schema_version: "1",
-        id: "unsafe",
-        version: "0.0.1",
-        name: "Unsafe",
-        summary: "Unsafe recipe",
-        description: "Used for archive validation tests.",
-        skills: [
-            {
-                id: "RECIPE_SKILL",
-                summary: "Recipe skill",
-                file: "skills/recipe.md",
-            },
-        ],
-        agents: [
-            {
-                id: "RECIPE_AGENT",
-                display_name: "Recipe Agent",
-                role: "executor",
-                summary: "Recipe agent",
-                skills: ["RECIPE_SKILL"],
-                tools: ["RECIPE_TOOL"],
-                file: "agents/recipe.md",
-            },
-        ],
-        tools: [
-            { id: "RECIPE_TOOL", summary: "Recipe tool", runtime: "bash", entrypoint: "tools/run.sh" },
-        ],
-        scenarios: [
-            {
-                id: "RECIPE_SCENARIO",
-                name: "Recipe Scenario",
-                summary: "Recipe scenario",
-                use_when: ["Unsafe validation fixture"],
-                required_inputs: [],
-                outputs: [],
-                permissions: [],
-                artifacts: [],
-                agents_involved: ["RECIPE_AGENT"],
-                skills_used: ["RECIPE_SKILL"],
-                tools_used: ["RECIPE_TOOL"],
-                run_profile: { mode: "analysis" },
-                file: "scenarios/recipe-scenario.json",
-            },
-        ],
-    };
-    await writeFile(path.join(recipeDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-    const agentsDir = path.join(recipeDir, "agents");
-    await mkdir(agentsDir, { recursive: true });
-    await writeFile(path.join(agentsDir, "recipe.md"), "# Recipe Agent\n\nFollow the unsafe archive validation path.\n", "utf8");
-    const skillsDir = path.join(recipeDir, "skills");
-    await mkdir(skillsDir, { recursive: true });
-    await writeFile(path.join(skillsDir, "recipe.md"), "# Recipe Skill\n\nInspect archive contents before materialization.\n", "utf8");
-    const toolsDir = path.join(recipeDir, "tools");
-    await mkdir(toolsDir, { recursive: true });
-    await writeFile(path.join(toolsDir, "run.sh"), "#!/usr/bin/env bash\n", "utf8");
-    const scenariosDir = path.join(recipeDir, "scenarios");
-    await mkdir(scenariosDir, { recursive: true });
-    await writeFile(path.join(scenariosDir, "recipe-scenario.json"), JSON.stringify({
-        schema_version: "1",
-        id: "RECIPE_SCENARIO",
-        summary: "Recipe scenario",
-        goal: "Exercise unsafe archive validation.",
-        task_template: {
-            title: "Unsafe archive task",
-            description: "Validate unsafe archive handling.",
-            owner: "CODER",
-        },
-        inputs: [],
-        outputs: [],
-        steps: [{ tool: "RECIPE_TOOL" }],
-    }, null, 2), "utf8");
-    const entryPath = opts.entryPath ?? "../evil.txt";
-    await writeFile(path.join(baseDir, "evil.txt"), "evil", "utf8");
-    const archivePath = opts.format === "zip" ? path.join(baseDir, "unsafe.zip") : path.join(baseDir, "unsafe.tar.gz");
-    if (opts.format === "zip") {
-        await execFileAsync("zip", ["-qr", archivePath, ".", entryPath], { cwd: recipeDir });
-        return archivePath;
-    }
-    // Build a deterministic tar.gz containing a traversal entry, without relying on system tar behavior.
-    // This keeps the archive validation tests stable across GNU tar / bsdtar.
-    const tar = buildTar([
-        {
-            name: "./manifest.json",
-            data: Buffer.from(JSON.stringify(manifest, null, 2) + "\n", "utf8"),
-        },
-        { name: entryPath, data: Buffer.from("evil\n", "utf8") },
-    ]);
-    const gz = gzipSync(tar);
-    await writeFile(archivePath, gz);
-    return archivePath;
-}
-function buildTar(entries) {
-    const out = [];
-    for (const ent of entries) {
-        const header = tarHeader({
-            name: ent.name,
-            size: ent.data.length,
-            mtime: 0,
-            typeflag: "0",
-        });
-        out.push(header, ent.data, zeroPadTo512(ent.data.length));
-    }
-    // Two empty blocks mark end-of-archive.
-    out.push(Buffer.alloc(1024, 0));
-    return Buffer.concat(out);
-}
-function zeroPadTo512(n) {
-    const rem = n % 512;
-    if (rem === 0)
-        return Buffer.alloc(0);
-    return Buffer.alloc(512 - rem, 0);
-}
-function tarHeader(opts) {
-    const buf = Buffer.alloc(512, 0);
-    writeTarString(buf, 0, 100, opts.name);
-    writeTarOctal(buf, 100, 8, 0o644); // mode
-    writeTarOctal(buf, 108, 8, 0); // uid
-    writeTarOctal(buf, 116, 8, 0); // gid
-    writeTarOctal(buf, 124, 12, opts.size);
-    writeTarOctal(buf, 136, 12, opts.mtime);
-    // checksum field must be treated as spaces for calculation
-    buf.fill(0x20, 148, 156);
-    writeTarString(buf, 156, 1, opts.typeflag);
-    writeTarString(buf, 257, 6, "ustar"); // magic
-    writeTarString(buf, 263, 2, "00"); // version
-    const sum = buf.reduce((acc, b) => acc + b, 0);
-    writeTarChecksum(buf, sum);
-    return buf;
-}
-function writeTarString(buf, offset, length, value) {
-    const b = Buffer.from(value, "utf8");
-    b.copy(buf, offset, 0, Math.min(length, b.length));
-}
-function writeTarOctal(buf, offset, length, value) {
-    const raw = Math.max(0, value).toString(8);
-    const padded = raw.padStart(length - 1, "0") + "\0";
-    writeTarString(buf, offset, length, padded);
-}
-function writeTarChecksum(buf, sum) {
-    // 6 digits, NUL, space (common convention).
-    const raw = Math.max(0, sum).toString(8).padStart(6, "0");
-    writeTarString(buf, 148, 8, `${raw}\0 `);
-}
-export async function createUpgradeBundle(files) {
-    const manifestUrl = new URL("../../assets/framework.manifest.json", import.meta.url);
-    const manifestText = typeof files["framework.manifest.json"] === "string"
-        ? files["framework.manifest.json"]
-        : await readFile(fileURLToPath(manifestUrl), "utf8");
-    const manifest = JSON.parse(manifestText);
-    const normalizedFiles = {};
-    for (const [relPath, content] of Object.entries(files)) {
-        // Tests historically authored bundles using workspace-destination paths. Upgrade now reads
-        // upstream files via manifest source_path (package assets layout).
-        const mapped = relPath.startsWith(".agentplane/agents/")
-            ? relPath.replace(/^\.agentplane\/agents\//, "agents/")
-            : relPath;
-        normalizedFiles[mapped] = content;
-    }
-    // Ensure the bundle always carries its manifest at the root.
-    normalizedFiles["framework.manifest.json"] ??= manifestText;
-    if (manifest.schema_version === 1 && Array.isArray(manifest.files)) {
-        for (const entry of manifest.files) {
-            if (!entry?.required)
-                continue;
-            const sourceRel = (entry.source_path ?? entry.path ?? "").trim();
-            if (!sourceRel)
-                continue;
-            if (normalizedFiles[sourceRel] !== undefined)
-                continue;
-            if (entry.type === "json")
-                normalizedFiles[sourceRel] = "{}\n";
-            else if (sourceRel.endsWith(".md"))
-                normalizedFiles[sourceRel] = "# AGENTS\n";
-            else
-                normalizedFiles[sourceRel] = "\n";
-        }
-    }
-    const baseDir = await mkdtemp(path.join(os.tmpdir(), "agentplane-upgrade-bundle-"));
-    const bundleDir = path.join(baseDir, "bundle");
-    await mkdir(bundleDir, { recursive: true });
-    for (const [relPath, content] of Object.entries(normalizedFiles)) {
-        const fullPath = path.join(bundleDir, relPath);
-        await mkdir(path.dirname(fullPath), { recursive: true });
-        await writeFile(fullPath, content, "utf8");
-    }
-    const bundlePath = path.join(baseDir, "agentplane-upgrade.tar.gz");
-    await execFileAsync("tar", ["-czf", bundlePath, "-C", bundleDir, "."]);
-    const checksum = createHash("sha256")
-        .update(await readFile(bundlePath))
-        .digest("hex");
-    const checksumPath = `${bundlePath}.sha256`;
-    await writeFile(checksumPath, `${checksum}  agentplane-upgrade.tar.gz\n`, "utf8");
-    return { bundlePath, checksumPath };
-}
-export async function mkGitRepoRootWithBranch(branch) {
-    const root = await mkGitRepoRoot();
-    await execFileAsync("git", ["checkout", "-b", branch], { cwd: root, env: cleanGitEnv() });
-    return root;
-}
-export async function configureGitUser(root) {
-    await execFileAsync("git", ["config", "user.email", "test@example.com"], {
-        cwd: root,
-        env: cleanGitEnv(),
-    });
-    await execFileAsync("git", ["config", "user.name", "Test User"], {
-        cwd: root,
-        env: cleanGitEnv(),
-    });
-}
-export function cleanGitEnv() {
-    const env = { ...process.env };
-    delete env.GIT_DIR;
-    delete env.GIT_WORK_TREE;
-    delete env.GIT_COMMON_DIR;
-    delete env.GIT_INDEX_FILE;
-    delete env.GIT_OBJECT_DIRECTORY;
-    delete env.GIT_ALTERNATE_OBJECT_DIRECTORIES;
-    env.GIT_CONFIG_GLOBAL = "/dev/null";
-    env.GIT_CONFIG_SYSTEM = "/dev/null";
-    env.GIT_TERMINAL_PROMPT = "0";
-    env.GIT_AUTHOR_NAME = env.GIT_AUTHOR_NAME ?? "Agentplane Test";
-    env.GIT_AUTHOR_EMAIL = env.GIT_AUTHOR_EMAIL ?? "agentplane-test@example.com";
-    env.GIT_COMMITTER_NAME = env.GIT_COMMITTER_NAME ?? "Agentplane Test";
-    env.GIT_COMMITTER_EMAIL = env.GIT_COMMITTER_EMAIL ?? "agentplane-test@example.com";
-    return env;
-}
-export async function pathExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function gitBranchExists(root, branch) {
-    try {
-        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
-            cwd: root,
-            env: cleanGitEnv(),
-        });
-        return true;
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === 1)
-            return false;
-        throw err;
-    }
-}
-export async function commitAll(root, message) {
-    await execFileAsync("git", ["add", "."], { cwd: root, env: cleanGitEnv() });
-    await execFileAsync("git", ["commit", "--no-verify", "-m", message], {
-        cwd: root,
-        env: cleanGitEnv(),
-    });
-}
-export async function commitPathsIfChanged(root, paths, message) {
-    await execFileAsync("git", ["add", "--", ...paths], { cwd: root, env: cleanGitEnv() });
-    const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only", "--", ...paths], {
-        cwd: root,
-        env: cleanGitEnv(),
-    });
-    if (!stdout.trim())
-        return false;
-    await execFileAsync("git", ["commit", "--no-verify", "-m", message], {
-        cwd: root,
-        env: cleanGitEnv(),
-    });
-    return true;
-}
-export async function stageGitignoreIfPresent(root) {
-    const gitignorePath = path.join(root, ".gitignore");
-    if (!(await pathExists(gitignorePath)))
-        return;
-    await execFileAsync("git", ["add", ".gitignore"], { cwd: root, env: cleanGitEnv() });
-}
+export * from "../testing/index.js";