@fitlab-ai/agent-infra 0.8.5 → 0.9.0

package/dist/lib/internal/platform-checks.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import { fetchPlatformCheckLogs, inspectRequiredChecks, resolvePlatformCheckRun, watchPlatformChecks } from '../platform/pr-checks.js';
+const USAGE = `Usage: agent-infra-internal platform-checks inspect <task-ref> [--cwd <path>]
+       agent-infra-internal platform-checks watch <task-ref> --interval-seconds <N> --deadline-seconds <N> [--cwd <path>]
+       agent-infra-internal platform-checks resolve-run <task-ref> --check-name <name> [--details-url <url>] [--cwd <path>]
+       agent-infra-internal platform-checks logs <task-ref> --run <id> [--job <id>] [--cwd <path>]
+`;
+const VALUE_FLAGS = new Set(['--cwd', '--interval-seconds', '--deadline-seconds', '--check-name', '--details-url', '--run', '--job']);
+function key(flag) {
+    return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'CHECKS_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    if (output.status === 'failed')
+        process.exitCode = 1;
+    if (output.status === 'blocked')
+        process.exitCode = 2;
+}
+function parse(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!VALUE_FLAGS.has(flag))
+            return { values, error: `unknown option '${flag}'` };
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[key(flag)] = value;
+    }
+    return { values };
+}
+function positive(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : null;
+}
+async function platformChecks(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['inspect', 'watch', 'resolve-run', 'logs'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const taskRef = args[1];
+    if (!taskRef || taskRef.startsWith('--')) {
+        fail(`${operation} requires a task ref`);
+        return;
+    }
+    const parsed = parse(args, 2);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(values.cwd || process.cwd());
+    const allowed = {
+        inspect: ['cwd'],
+        watch: ['cwd', 'intervalSeconds', 'deadlineSeconds'],
+        'resolve-run': ['cwd', 'checkName', 'detailsUrl'],
+        logs: ['cwd', 'run', 'job']
+    };
+    const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
+    if (unexpected) {
+        fail(`${operation} does not accept --${unexpected}`);
+        return;
+    }
+    if (operation === 'inspect') {
+        finish(inspectRequiredChecks(taskRef, { cwd }));
+        return;
+    }
+    if (operation === 'resolve-run') {
+        if (!values.checkName) {
+            fail('resolve-run requires --check-name');
+            return;
+        }
+        finish(resolvePlatformCheckRun(taskRef, { cwd, checkName: values.checkName, detailsUrl: values.detailsUrl }));
+        return;
+    }
+    if (operation === 'logs') {
+        const run = positive(values.run);
+        const job = values.job === undefined ? undefined : positive(values.job);
+        if (!run || values.job !== undefined && !job) {
+            fail('logs requires a positive --run and optional positive --job');
+            return;
+        }
+        finish(fetchPlatformCheckLogs(taskRef, { cwd, run, job: job || undefined }));
+        return;
+    }
+    const intervalSeconds = positive(values.intervalSeconds);
+    const deadlineSeconds = positive(values.deadlineSeconds);
+    if (!intervalSeconds || !deadlineSeconds) {
+        fail('watch requires positive --interval-seconds and --deadline-seconds');
+        return;
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    process.once('SIGINT', abort);
+    process.once('SIGTERM', abort);
+    try {
+        finish(await watchPlatformChecks(taskRef, { cwd, intervalSeconds, deadlineSeconds, signal: controller.signal }));
+    }
+    finally {
+        process.removeListener('SIGINT', abort);
+        process.removeListener('SIGTERM', abort);
+    }
+}
+export { platformChecks };
+//# sourceMappingURL=platform-checks.js.map

package/dist/lib/internal/platform-comment.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkPlatformCommentOwner, listPlatformComments, syncPlatformComment } from '../platform/issue-comments.js';
+const USAGE = `Usage: agent-infra-internal platform-comment list --issue <N> [--cwd <path>]
+       agent-infra-internal platform-comment owner <task-ref> [--cwd <path>]
+       agent-infra-internal platform-comment sync <task-ref> --kind <kind> --agent <agent> [--artifact <file>] [--body-file <path|->] [--status-label <label>] [--backfill] [--cwd <path>]
+`;
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'COMMENT_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(result) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+    if (result.status === 'blocked')
+        process.exitCode = 2;
+}
+function parseFlags(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!['--issue', '--cwd', '--kind', '--agent', '--artifact', '--body-file', '--status-label', '--backfill'].includes(flag)) {
+            return { values, error: `unknown option '${flag}'` };
+        }
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        if (flag === '--backfill') {
+            values.backfill = true;
+            continue;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+    }
+    return { values };
+}
+function readBodyFile(value, cwd) {
+    if (value === '-')
+        return fs.readFileSync(0, 'utf8');
+    return fs.readFileSync(path.resolve(cwd, value), 'utf8');
+}
+function platformComment(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['list', 'owner', 'sync'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const hasTaskRef = operation !== 'list';
+    const taskRef = hasTaskRef ? args[1] : undefined;
+    if (hasTaskRef && (!taskRef || taskRef.startsWith('--'))) {
+        fail(`${operation} requires a task ref`);
+        return;
+    }
+    const parsed = parseFlags(args, hasTaskRef ? 2 : 1);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const cwd = path.resolve(typeof parsed.values.cwd === 'string' ? parsed.values.cwd : process.cwd());
+    if (operation === 'list') {
+        const issue = Number(parsed.values.issue);
+        if (!Number.isInteger(issue) || issue <= 0) {
+            fail('list requires a positive --issue');
+            return;
+        }
+        const unexpected = Object.keys(parsed.values).find((key) => !['issue', 'cwd'].includes(key));
+        if (unexpected) {
+            fail(`list does not accept '--${unexpected}'`);
+            return;
+        }
+        finish(listPlatformComments(issue, cwd));
+        return;
+    }
+    if (operation === 'owner') {
+        const unexpected = Object.keys(parsed.values).find((key) => key !== 'cwd');
+        if (unexpected) {
+            fail(`owner does not accept '--${unexpected}'`);
+            return;
+        }
+        finish(checkPlatformCommentOwner(taskRef, { cwd }));
+        return;
+    }
+    const kind = parsed.values.kind;
+    const agent = parsed.values.agent;
+    if (!['task', 'artifact', 'summary', 'cancel'].includes(String(kind))) {
+        fail('sync requires a valid --kind');
+        return;
+    }
+    if (typeof agent !== 'string' || !agent) {
+        fail('sync requires --agent');
+        return;
+    }
+    if (kind === 'artifact' && typeof parsed.values.artifact !== 'string') {
+        fail('artifact sync requires --artifact');
+        return;
+    }
+    if ((kind === 'summary' || kind === 'cancel') && typeof parsed.values.bodyFile !== 'string') {
+        fail(`${kind} sync requires --body-file`);
+        return;
+    }
+    let body;
+    try {
+        if (typeof parsed.values.bodyFile === 'string')
+            body = readBodyFile(parsed.values.bodyFile, cwd);
+    }
+    catch (error) {
+        fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    finish(syncPlatformComment(taskRef, {
+        kind: kind,
+        agent,
+        artifact: typeof parsed.values.artifact === 'string' ? parsed.values.artifact : undefined,
+        body,
+        backfill: parsed.values.backfill === true,
+        cwd
+    }));
+}
+export { platformComment };
+//# sourceMappingURL=platform-comment.js.map

package/dist/lib/internal/platform-context.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { resolvePlatformContext } from '../platform/context.js';
+const USAGE = 'Usage: agent-infra-internal platform-context resolve [--cwd <path>]\n';
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PLATFORM_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function platformContext(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (args[0] !== 'resolve') {
+        fail("operation must be 'resolve'");
+        return;
+    }
+    let cwd = process.cwd();
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag !== '--cwd') {
+            fail(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            fail(`duplicate option '${flag}'`);
+            return;
+        }
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            fail(`option '${flag}' requires a value`);
+            return;
+        }
+        seen.add(flag);
+        cwd = path.resolve(value);
+    }
+    const result = resolvePlatformContext({ cwd });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+    if (result.status === 'blocked')
+        process.exitCode = 2;
+}
+export { platformContext };
+//# sourceMappingURL=platform-context.js.map

package/dist/lib/internal/platform-issue.js

@@ -0,0 +1,142 @@
+import path from 'node:path';
+import { bindPlatformIssue, createPlatformIssue, inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
+const USAGE = `Usage: agent-infra-internal platform-issue inspect <task-ref> [--cwd <path>]
+       agent-infra-internal platform-issue create <task-ref> --agent <agent> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-issue bind <task-ref> --issue <N> --agent <agent> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-issue sync <task-ref> --agent <agent> [--status <suffix|none>] [--assignees current|none] [--milestone initial|specific|none] [--issue-type] [--fields] [--requirements] [--in-labels from-diff|none] [--base <branch>] [--state open|closed] [--close-reason completed|not_planned] [--dry-run] [--cwd <path>]
+`;
+const BOOLEAN_FLAGS = new Set(['--dry-run', '--issue-type', '--fields', '--requirements']);
+const VALUE_FLAGS = new Set([
+    '--cwd', '--agent', '--issue', '--status', '--assignees', '--milestone', '--in-labels', '--base', '--state', '--close-reason'
+]);
+function key(flag) {
+    return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ISSUE_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    if (output.status === 'failed')
+        process.exitCode = 1;
+    if (output.status === 'blocked')
+        process.exitCode = 2;
+}
+function parse(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!BOOLEAN_FLAGS.has(flag) && !VALUE_FLAGS.has(flag))
+            return { values, error: `unknown option '${flag}'` };
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        if (BOOLEAN_FLAGS.has(flag)) {
+            values[key(flag)] = true;
+            continue;
+        }
+        const value = args[++index];
+        if (!value || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[key(flag)] = value;
+    }
+    return { values };
+}
+function oneOf(values, name, allowed) {
+    const value = values[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !allowed.includes(value))
+        throw new Error(`--${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)} must be one of ${allowed.join('|')}`);
+    return value;
+}
+function platformIssue(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['inspect', 'create', 'bind', 'sync'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const taskRef = args[1];
+    if (!taskRef || taskRef.startsWith('--')) {
+        fail(`${operation} requires a task ref`);
+        return;
+    }
+    const parsed = parse(args, 2);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+    const allowed = {
+        inspect: ['cwd'], create: ['cwd', 'agent', 'dryRun'], bind: ['cwd', 'agent', 'dryRun', 'issue'],
+        sync: ['cwd', 'agent', 'dryRun', 'status', 'assignees', 'milestone', 'issueType', 'fields', 'requirements', 'inLabels', 'base', 'state', 'closeReason']
+    };
+    const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
+    if (unexpected) {
+        fail(`${operation} does not accept --${unexpected}`);
+        return;
+    }
+    if (operation === 'inspect') {
+        finish(inspectPlatformIssue(taskRef, { cwd }));
+        return;
+    }
+    if (typeof values.agent !== 'string' || !values.agent) {
+        fail(`${operation} requires --agent`);
+        return;
+    }
+    if (operation === 'create') {
+        finish(createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true }));
+        return;
+    }
+    if (operation === 'bind') {
+        const issue = Number(values.issue);
+        if (!Number.isInteger(issue) || issue <= 0) {
+            fail('bind requires a positive --issue');
+            return;
+        }
+        finish(bindPlatformIssue(taskRef, { cwd, agent: values.agent, issue, dryRun: values.dryRun === true }));
+        return;
+    }
+    try {
+        const assignees = oneOf(values, 'assignees', ['current', 'none']);
+        const milestone = oneOf(values, 'milestone', ['initial', 'specific', 'none']);
+        const inLabels = oneOf(values, 'inLabels', ['from-diff', 'none']);
+        const state = oneOf(values, 'state', ['open', 'closed']);
+        const closeReason = oneOf(values, 'closeReason', ['completed', 'not_planned']);
+        if (inLabels === 'from-diff' && typeof values.base !== 'string')
+            throw new Error('--in-labels from-diff requires --base');
+        if (inLabels !== 'from-diff' && values.base !== undefined)
+            throw new Error('--base requires --in-labels from-diff');
+        if (closeReason && state !== 'closed')
+            throw new Error('--close-reason requires --state closed');
+        const desiredKeys = ['status', 'assignees', 'milestone', 'issueType', 'fields', 'requirements', 'inLabels', 'state'];
+        if (!desiredKeys.some((name) => values[name] !== undefined))
+            throw new Error('sync requires at least one desired-state option');
+        finish(syncPlatformIssue(taskRef, {
+            cwd, agent: values.agent, dryRun: values.dryRun === true,
+            status: typeof values.status === 'string' ? values.status : undefined,
+            assignees: assignees,
+            milestone: milestone,
+            issueType: values.issueType === true,
+            fields: values.fields === true,
+            requirements: values.requirements === true,
+            inLabels: inLabels,
+            base: typeof values.base === 'string' ? values.base : undefined,
+            state: state,
+            closeReason: closeReason
+        }));
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+}
+export { platformIssue };
+//# sourceMappingURL=platform-issue.js.map

package/dist/lib/internal/platform-pr.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { summaryContext, syncPullRequestSummary } from '../platform/pr-summary.js';
+const USAGE = `Usage: agent-infra-internal platform-pr inspect <task-ref> [--cwd <path>]
+       agent-infra-internal platform-pr create <task-ref> --agent <agent> --base <branch> --head <branch> --title-file <path|-> --body-file <path|-> [--draft] [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr bind <task-ref> --pr <N> --agent <agent> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr sync <task-ref> --agent <agent> [--metadata] [--closing-issue] [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr summary-context <task-ref> [--cwd <path>]
+       agent-infra-internal platform-pr summary-sync <task-ref> --agent <agent> --body-file <path|-> [--dry-run] [--cwd <path>]
+`;
+const BOOLEAN_FLAGS = new Set(['--draft', '--dry-run', '--metadata', '--closing-issue']);
+const VALUE_FLAGS = new Set(['--cwd', '--agent', '--base', '--head', '--title-file', '--body-file', '--pr']);
+function key(flag) {
+    return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PR_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    if (output.status === 'failed')
+        process.exitCode = 1;
+    if (output.status === 'blocked')
+        process.exitCode = 2;
+}
+function parse(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!BOOLEAN_FLAGS.has(flag) && !VALUE_FLAGS.has(flag))
+            return { values, error: `unknown option '${flag}'` };
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        if (BOOLEAN_FLAGS.has(flag)) {
+            values[key(flag)] = true;
+            continue;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[key(flag)] = value;
+    }
+    return { values };
+}
+function readFile(value, cwd) {
+    return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
+}
+function platformPr(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['inspect', 'create', 'bind', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const taskRef = args[1];
+    if (!taskRef || taskRef.startsWith('--')) {
+        fail(`${operation} requires a task ref`);
+        return;
+    }
+    const parsed = parse(args, 2);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+    const allowed = {
+        inspect: ['cwd'],
+        create: ['cwd', 'agent', 'base', 'head', 'titleFile', 'bodyFile', 'draft', 'dryRun'],
+        bind: ['cwd', 'agent', 'pr', 'dryRun'],
+        sync: ['cwd', 'agent', 'metadata', 'closingIssue', 'dryRun'],
+        'summary-context': ['cwd'],
+        'summary-sync': ['cwd', 'agent', 'bodyFile', 'dryRun']
+    };
+    const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
+    if (unexpected) {
+        fail(`${operation} does not accept --${unexpected}`);
+        return;
+    }
+    if (operation === 'inspect') {
+        finish(inspectPlatformPullRequest(taskRef, { cwd }));
+        return;
+    }
+    if (operation === 'summary-context') {
+        finish(summaryContext(taskRef, { cwd }));
+        return;
+    }
+    if (typeof values.agent !== 'string' || !values.agent) {
+        fail(`${operation} requires --agent`);
+        return;
+    }
+    if (operation === 'bind') {
+        const pr = Number(values.pr);
+        if (!Number.isInteger(pr) || pr <= 0) {
+            fail('bind requires a positive --pr');
+            return;
+        }
+        finish(bindPlatformPullRequest(taskRef, { cwd, agent: values.agent, pr, dryRun: values.dryRun === true }));
+        return;
+    }
+    if (operation === 'sync') {
+        if (values.metadata !== true && values.closingIssue !== true) {
+            fail('sync requires --metadata or --closing-issue');
+            return;
+        }
+        finish(syncPlatformPullRequest(taskRef, { cwd, agent: values.agent, metadata: values.metadata === true, closingIssue: values.closingIssue === true, dryRun: values.dryRun === true }));
+        return;
+    }
+    if (operation === 'summary-sync') {
+        if (typeof values.bodyFile !== 'string') {
+            fail('summary-sync requires --body-file');
+            return;
+        }
+        try {
+            finish(syncPullRequestSummary(taskRef, { cwd, agent: values.agent, body: readFile(values.bodyFile, cwd), dryRun: values.dryRun === true }));
+        }
+        catch (error) {
+            fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+    }
+    if (typeof values.base !== 'string' || typeof values.head !== 'string' || typeof values.titleFile !== 'string' || typeof values.bodyFile !== 'string') {
+        fail('create requires --base, --head, --title-file and --body-file');
+        return;
+    }
+    try {
+        finish(createPlatformPullRequest(taskRef, {
+            cwd, agent: values.agent, base: values.base, head: values.head,
+            title: readFile(values.titleFile, cwd), body: readFile(values.bodyFile, cwd),
+            draft: values.draft === true, dryRun: values.dryRun === true
+        }));
+    }
+    catch (error) {
+        fail(`unable to read PR payload file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export { platformPr };
+//# sourceMappingURL=platform-pr.js.map