Codex
415 lines
16 KiB
TypeScript
415 lines
16 KiB
TypeScript
// SPEC: PJ2026-01060307 控制面模块化 draft-2026-06-25-p0. options module for scripts/src/agentrun.ts.
|
|
|
|
// Moved mechanically from scripts/src/agentrun.ts:1653-2021 for #903.
|
|
|
|
// SPEC: PJ2026-01020108 cancel lifecycle + PJ2026-01020205 AipodSpec binding + PJ2026-01020302 session policy + PJ2026-01020305 cancel control + PJ2026-01060305/06 YAML execution policy and bounded output draft-2026-06-25-p0.
|
|
// Exposes AgentRun lane-scoped policy, AipodSpec SecretRef binding, cancel lifecycle, and bounded default output in the UniDesk CLI.
|
|
import { chmodSync, copyFileSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { rootPath, type UniDeskConfig } from "../config";
|
|
import type { RenderedCliResult } from "../output";
|
|
import { applyLocalCaddyManagedSite } from "../pk01-caddy";
|
|
import { runSshCommandCapture, type SshCaptureResult } from "../ssh";
|
|
import { runRemoteSshCommandCapture } from "../remote";
|
|
import { startJob } from "../jobs";
|
|
import {
|
|
AGENTRUN_CONFIG_PATH,
|
|
agentRunLaneSummary,
|
|
agentRunPipelineRunName,
|
|
agentRunProviderCredentialRefs,
|
|
resolveAgentRunLaneTarget,
|
|
type AgentRunCancelLifecycleSpec,
|
|
type AgentRunLaneSpec,
|
|
} from "../agentrun-lanes";
|
|
import {
|
|
agentRunImageArtifact,
|
|
placeholderAgentRunImage,
|
|
renderedFilesDigest,
|
|
renderedObjectsDigest,
|
|
renderAgentRunControlPlaneManifests,
|
|
renderAgentRunGitopsFiles,
|
|
type AgentRunArtifactService,
|
|
} from "../agentrun-manifests";
|
|
import { sha256Fingerprint } from "../platform-infra-ops-library";
|
|
|
|
import type { AgentRunResourceRef, AgentRunRestTargetOptions } from "./utils";
|
|
import { renderAgentRunSessionPolicyExplanation } from "./config";
|
|
import { optionValue, parseConfirmOptions, validateOptions } from "./control-plane";
|
|
import { firstKnownString, parseResourceKind } from "./render";
|
|
import { isAgentRunPipelineRunName, isGitSha, record, stringOrNull } from "./utils";
|
|
|
|
export function renderFailureLines(value: Record<string, unknown>): string[] {
|
|
const terminalClassification = record(value.terminalClassification);
|
|
const nestedTerminalClassification = Object.keys(terminalClassification).length > 0
|
|
? terminalClassification
|
|
: record(record(value.liveness).terminalClassification);
|
|
const failureKind = stringOrNull(value.failureKind)
|
|
?? stringOrNull(nestedTerminalClassification.failureKind)
|
|
?? stringOrNull(value.degradedReason);
|
|
const failureMessage = stringOrNull(value.failureMessage)
|
|
?? stringOrNull(nestedTerminalClassification.failureMessage)
|
|
?? stringOrNull(value.message)
|
|
?? stringOrNull(value.reason);
|
|
const category = stringOrNull(nestedTerminalClassification.category);
|
|
const timeoutKind = stringOrNull(nestedTerminalClassification.timeoutKind);
|
|
const timeoutState = stringOrNull(nestedTerminalClassification.timeoutState);
|
|
const providerInterruption = stringOrNull(nestedTerminalClassification.providerInterruption);
|
|
const lastActivity = stringOrNull(nestedTerminalClassification.lastActivityKind);
|
|
const lastActivitySeq = nestedTerminalClassification.lastActivitySeq;
|
|
const lines: string[] = [];
|
|
if (failureKind !== null) lines.push(`Failure: ${failureKind}`);
|
|
if (failureMessage !== null) lines.push(`Message: ${failureMessage}`);
|
|
if (category !== null) lines.push(`Category: ${category}`);
|
|
if (timeoutKind !== null || timeoutState !== null) lines.push(`Timeout: ${displayValue(timeoutKind)} / ${displayValue(timeoutState)}`);
|
|
if (providerInterruption !== null) lines.push(`Provider: ${providerInterruption}`);
|
|
if (lastActivity !== null) lines.push(`LastActivity: ${lastActivity}${lastActivitySeq === undefined ? "" : ` seq=${String(lastActivitySeq)}`}`);
|
|
return lines;
|
|
}
|
|
|
|
export function renderResourceNextLines(ref: AgentRunResourceRef, value: Record<string, unknown>): string[] {
|
|
const supervisor = record(value.supervisor);
|
|
const runId = firstKnownString(value.runId, value.activeRunId, value.lastRunId, supervisor.runId, supervisor.activeRunId, supervisor.lastRunId);
|
|
const commandId = firstKnownString(value.commandId, value.activeCommandId, value.lastCommandId, supervisor.commandId, supervisor.activeCommandId, supervisor.lastCommandId);
|
|
const runnerJobId = stringOrNull(value.runnerJobId) ?? (ref.kind === "runnerjob" ? ref.name : null);
|
|
const sessionId = firstKnownString(value.sessionId, supervisor.sessionId);
|
|
const lines = [
|
|
runId === null ? null : `bun scripts/cli.ts agentrun events run/${runId} --after-seq 0 --limit 100`,
|
|
sessionId === null ? null : `bun scripts/cli.ts agentrun logs session/${sessionId} --tail 100`,
|
|
runId === null || commandId === null ? null : `bun scripts/cli.ts agentrun result run/${runId} --command ${commandId}`,
|
|
runId === null || commandId === null ? null : `bun scripts/cli.ts agentrun describe command/${commandId} --run ${runId} --full`,
|
|
runId === null || runnerJobId === null ? null : `bun scripts/cli.ts agentrun describe runnerjob/${runnerJobId} --run ${runId} --full`,
|
|
ref.kind !== "session" || sessionId === null ? null : `bun scripts/cli.ts agentrun send session/${sessionId} --prompt-stdin`,
|
|
];
|
|
const unique: string[] = [];
|
|
for (const line of lines) {
|
|
if (line !== null && !unique.includes(line)) unique.push(line);
|
|
}
|
|
return unique.slice(0, 5);
|
|
}
|
|
|
|
export function parseTaskManifest(raw: string, source: string): Record<string, unknown> {
|
|
const parsed = source.endsWith(".json") ? JSON.parse(raw) as unknown : Bun.YAML.parse(raw) as unknown;
|
|
const input = record(parsed);
|
|
const kind = stringOrNull(input.kind);
|
|
if (kind !== null && kind.toLowerCase() !== "task") throw new Error("apply currently supports kind: Task only");
|
|
const spec = record(input.spec);
|
|
const payload = Object.keys(spec).length > 0 ? spec : input;
|
|
if (!isRecord(payload.payload) && !isRecord(payload.executionPolicy) && stringOrNull(payload.title) === null) {
|
|
throw new Error("task manifest must contain spec with an AgentRun task payload");
|
|
}
|
|
return payload;
|
|
}
|
|
|
|
export function nextPagedResourceCommand(command: string, nextAfterSeq: string, limit: number): string {
|
|
const parts = command
|
|
.replace(/\s+--after-seq\s+\S+/gu, "")
|
|
.replace(/\s+--tail(?:\s+\S+)?/gu, "")
|
|
.replace(/\s+--limit\s+\S+/gu, "")
|
|
.trim();
|
|
return `${parts} --after-seq ${nextAfterSeq} --limit ${limit}`;
|
|
}
|
|
|
|
export function agentRunExplain(kindRaw: string, args: string[] = [], options: AgentRunRestTargetOptions = { node: null, lane: null }): string {
|
|
if (kindRaw === "session-policy" || kindRaw === "provider-policy") return renderAgentRunSessionPolicyExplanation(args, options);
|
|
const kind = parseResourceKind(kindRaw);
|
|
if (kind === "task") {
|
|
return [
|
|
"KIND: task",
|
|
"FIELDS:",
|
|
" metadata.name: optional client name/idempotency hint",
|
|
" spec.tenantId, spec.projectId, spec.queue, spec.title",
|
|
" spec.payload.prompt or spec.payload.<structured fields>",
|
|
" spec.executionPolicy, spec.resourceBundleRef, spec.workspaceRef",
|
|
"",
|
|
"Apply example:",
|
|
" kind: Task",
|
|
" spec:",
|
|
" tenantId: unidesk",
|
|
" projectId: pikasTech/unidesk",
|
|
" queue: commander",
|
|
" title: Example",
|
|
" payload:",
|
|
" prompt: Do the work",
|
|
].join("\n");
|
|
}
|
|
return `KIND: ${kindRaw}\nUse get/describe with -o json to inspect the current stable UniDesk resource schema.`;
|
|
}
|
|
|
|
export function arrayRecords(value: unknown): Record<string, unknown>[] {
|
|
if (Array.isArray(value)) return value.map(record).filter((item) => Object.keys(item).length > 0);
|
|
if (typeof value === "object" && value !== null && Array.isArray((value as { items?: unknown }).items)) return arrayRecords((value as { items: unknown }).items);
|
|
return [];
|
|
}
|
|
|
|
export function renderTable(headers: string[], rows: string[][]): string {
|
|
const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length)));
|
|
const line = (values: string[]): string => values.map((value, index) => value.padEnd(widths[index] ?? value.length)).join(" ").trimEnd();
|
|
return [line(headers), ...rows.map(line)].join("\n");
|
|
}
|
|
|
|
export function resourceName(item: Record<string, unknown>): string {
|
|
const kind = String(item.kind ?? "resource");
|
|
return `${kind}/${shortId(displayValue(item.name))}`;
|
|
}
|
|
|
|
export function shortId(value: string): string {
|
|
if (value === "-" || value.length <= 18) return value;
|
|
const known = ["qt_", "run_", "cmd_", "rjob_"];
|
|
const prefix = known.find((item) => value.startsWith(item));
|
|
if (prefix !== undefined) return `${prefix}${value.slice(prefix.length, prefix.length + 8)}...`;
|
|
if (/^\w+-\d+/u.test(value)) return value.length > 28 ? `${value.slice(0, 25)}...` : value;
|
|
return `${value.slice(0, 14)}...`;
|
|
}
|
|
|
|
export function displayValue(value: unknown): string {
|
|
if (value === undefined || value === null || value === "") return "-";
|
|
return String(value);
|
|
}
|
|
|
|
export function stringOrDash(value: unknown): string {
|
|
return displayValue(value);
|
|
}
|
|
|
|
export function truncateOneLine(value: string, maxChars: number): string {
|
|
const oneLine = value.replace(/\s+/gu, " ").trim();
|
|
return oneLine.length <= maxChars ? oneLine : `${oneLine.slice(0, Math.max(0, maxChars - 3))}...`;
|
|
}
|
|
|
|
export function truncateMultiline(value: string, maxChars: number): string {
|
|
return value.length <= maxChars ? value : `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars; rerun with --full-text or --full]`;
|
|
}
|
|
|
|
export function relativeAge(iso: string | null): string {
|
|
if (iso === null) return "-";
|
|
const ms = Date.now() - Date.parse(iso);
|
|
if (!Number.isFinite(ms) || ms < 0) return "-";
|
|
const minutes = Math.floor(ms / 60000);
|
|
if (minutes < 60) return `${minutes}m`;
|
|
const hours = Math.floor(minutes / 60);
|
|
if (hours < 48) return `${hours}h`;
|
|
return `${Math.floor(hours / 24)}d`;
|
|
}
|
|
|
|
export function pickCompact(value: Record<string, unknown>, keys: string[]): Record<string, unknown> {
|
|
const picked: Record<string, unknown> = {};
|
|
for (const key of keys) {
|
|
if (value[key] !== undefined) picked[key] = value[key];
|
|
}
|
|
return picked;
|
|
}
|
|
|
|
export function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
export interface TriggerOptions extends DisclosureOptions {
|
|
confirm: boolean;
|
|
dryRun: boolean;
|
|
node: string | null;
|
|
lane: string | null;
|
|
wait: boolean;
|
|
}
|
|
|
|
export interface ConfirmOptions {
|
|
confirm: boolean;
|
|
dryRun: boolean;
|
|
}
|
|
|
|
export interface SecretSyncOptions extends ConfirmOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
}
|
|
|
|
export interface LaneConfirmOptions extends ConfirmOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
}
|
|
|
|
export interface RefreshOptions extends ConfirmOptions, DisclosureOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
}
|
|
|
|
export interface GitMirrorStatusOptions extends DisclosureOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
}
|
|
|
|
export interface GitMirrorOptions extends ConfirmOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
timeoutSeconds: number;
|
|
wait: boolean;
|
|
}
|
|
|
|
export interface CleanupRunnersOptions extends ConfirmOptions, DisclosureOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
timeoutSeconds: number;
|
|
forceActive: boolean;
|
|
}
|
|
|
|
export interface CleanupRunsOptions extends ConfirmOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
minAgeMinutes: number;
|
|
limit: number;
|
|
timeoutSeconds: number;
|
|
}
|
|
|
|
export interface CleanupReleasedPvOptions extends ConfirmOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
limit: number;
|
|
timeoutSeconds: number;
|
|
}
|
|
|
|
export interface DisclosureOptions {
|
|
full: boolean;
|
|
raw: boolean;
|
|
}
|
|
|
|
export interface StatusOptions extends DisclosureOptions {
|
|
node: string | null;
|
|
lane: string | null;
|
|
sourceCommit: string | null;
|
|
pipelineRun: string | null;
|
|
targetMode: "latest-source-head" | "source-commit" | "pipeline-run";
|
|
}
|
|
|
|
export interface TimedValue<T> {
|
|
value: T;
|
|
elapsedMs: number;
|
|
}
|
|
|
|
export function parseDisclosureOptions(args: string[]): DisclosureOptions {
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index];
|
|
if (arg === "--node" || arg === "--lane") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error(`${arg} requires a value`);
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg !== "--full" && arg !== "--raw") throw new Error(`unsupported status option: ${arg}`);
|
|
}
|
|
const raw = args.includes("--raw");
|
|
return { full: raw || args.includes("--full"), raw };
|
|
}
|
|
|
|
export function parseGitMirrorStatusOptions(args: string[]): GitMirrorStatusOptions {
|
|
validateOptions(args, new Set(["--full", "--raw"]), new Set(["--node", "--lane"]));
|
|
const raw = args.includes("--raw");
|
|
return {
|
|
full: raw || args.includes("--full"),
|
|
raw,
|
|
node: optionValue(args, "--node") ?? null,
|
|
lane: optionValue(args, "--lane") ?? null,
|
|
};
|
|
}
|
|
|
|
export function parseStatusOptions(args: string[]): StatusOptions {
|
|
let node: string | null = null;
|
|
let lane: string | null = null;
|
|
let sourceCommit: string | null = null;
|
|
let pipelineRun: string | null = null;
|
|
let full = false;
|
|
let raw = false;
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index];
|
|
if (arg === "--full") {
|
|
full = true;
|
|
continue;
|
|
}
|
|
if (arg === "--raw") {
|
|
raw = true;
|
|
full = true;
|
|
continue;
|
|
}
|
|
if (arg === "--node") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--node requires a value");
|
|
node = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--lane") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--lane requires a value");
|
|
lane = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--source-commit") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--source-commit requires a value");
|
|
if (!isGitSha(value)) throw new Error("--source-commit must be a full 40-character git SHA");
|
|
sourceCommit = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--pipeline-run") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--pipeline-run requires a value");
|
|
if (!isAgentRunPipelineRunName(value)) throw new Error("--pipeline-run must be an agentrun-vNN-ci-<12+ hex> PipelineRun name");
|
|
pipelineRun = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
throw new Error(`unsupported status option: ${arg}`);
|
|
}
|
|
if (sourceCommit !== null && pipelineRun !== null) throw new Error("control-plane status accepts only one of --source-commit or --pipeline-run");
|
|
return {
|
|
full,
|
|
raw,
|
|
node,
|
|
lane,
|
|
sourceCommit,
|
|
pipelineRun,
|
|
targetMode: pipelineRun !== null ? "pipeline-run" : sourceCommit !== null ? "source-commit" : "latest-source-head",
|
|
};
|
|
}
|
|
|
|
export function parseTriggerOptions(args: string[]): TriggerOptions {
|
|
const base = parseConfirmOptions(args);
|
|
let node: string | null = null;
|
|
let lane: string | null = null;
|
|
let wait = false;
|
|
let full = false;
|
|
let raw = false;
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index];
|
|
if (arg === "--confirm" || arg === "--dry-run") continue;
|
|
if (arg === "--full") {
|
|
full = true;
|
|
continue;
|
|
}
|
|
if (arg === "--raw") {
|
|
raw = true;
|
|
full = true;
|
|
continue;
|
|
}
|
|
if (arg === "--wait") {
|
|
wait = true;
|
|
continue;
|
|
}
|
|
if (arg === "--node") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--node requires a value");
|
|
node = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg === "--lane") {
|
|
const value = args[index + 1];
|
|
if (value === undefined || value.startsWith("--")) throw new Error("--lane requires a value");
|
|
lane = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
throw new Error(`unsupported trigger-current option: ${arg}`);
|
|
}
|
|
return { ...base, node, lane, wait, full, raw };
|
|
}
|