374 lines
13 KiB
JavaScript
374 lines
13 KiB
JavaScript
const config = flow.config || {};
|
|
const payload = flow.event.payload || {};
|
|
const commands = [];
|
|
|
|
function q(value) {
|
|
return "'" + String(value).replaceAll("'", "'\\''") + "'";
|
|
}
|
|
|
|
function trim(value) {
|
|
return String(value || "").trim();
|
|
}
|
|
|
|
function truncate(value, max) {
|
|
const textValue = String(value || "");
|
|
if (textValue.length <= max) {
|
|
return textValue;
|
|
}
|
|
return textValue.slice(0, max) + "\n...[truncated " + String(textValue.length - max) + " chars]";
|
|
}
|
|
|
|
function outputOf(result) {
|
|
if (typeof result?.output === "string") {
|
|
return result.output;
|
|
}
|
|
return JSON.stringify(result ?? {});
|
|
}
|
|
|
|
function exitCodeOf(result) {
|
|
if (typeof result?.exit_code === "number") {
|
|
return result.exit_code;
|
|
}
|
|
if (typeof result?.exitCode === "number") {
|
|
return result.exitCode;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function ok(result) {
|
|
return result.exit_code === 0;
|
|
}
|
|
|
|
function cfg(name, fallback) {
|
|
const value = config[name];
|
|
return typeof value === "string" && value.trim() ? value : fallback;
|
|
}
|
|
|
|
function enabled(name, fallback) {
|
|
const value = config[name];
|
|
return typeof value === "boolean" ? value : fallback;
|
|
}
|
|
|
|
function versionFromTag(tag) {
|
|
const match = String(tag).match(/[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?/);
|
|
return match ? match[0] : "";
|
|
}
|
|
|
|
async function env(name) {
|
|
if (!name) {
|
|
return "";
|
|
}
|
|
const result = await tools.exec_command({
|
|
cmd: "printf %s \"${" + name + ":-}\"",
|
|
workdir: flow.root,
|
|
yield_time_ms: 1000,
|
|
max_output_tokens: 2000
|
|
});
|
|
return trim(outputOf(result));
|
|
}
|
|
|
|
async function run(label, cmd, options = {}) {
|
|
const workdir = options.workdir || codexRepo;
|
|
text("\n### " + label + "\n$ " + cmd + "\n");
|
|
const raw = await tools.exec_command({
|
|
cmd,
|
|
workdir,
|
|
yield_time_ms: options.yield_time_ms || 1000,
|
|
max_output_tokens: options.max_output_tokens || 12000
|
|
});
|
|
const result = {
|
|
label,
|
|
cmd,
|
|
workdir,
|
|
exit_code: exitCodeOf(raw),
|
|
output: outputOf(raw)
|
|
};
|
|
commands.push({ ...result, output: truncate(result.output, 4000) });
|
|
text("exit_code=" + String(result.exit_code) + "\n" + truncate(result.output, options.textLimit || 12000) + "\n");
|
|
return result;
|
|
}
|
|
|
|
function finish(status, message, artifacts = {}) {
|
|
result({
|
|
status,
|
|
message,
|
|
artifacts: {
|
|
releaseTag,
|
|
version,
|
|
codexRepo,
|
|
targetBranch,
|
|
commands,
|
|
...artifacts
|
|
}
|
|
});
|
|
}
|
|
|
|
async function collectRebaseContext(rebaseOutput, beforeSha) {
|
|
const status = await run("rebase conflict status", "git status --short --branch", { max_output_tokens: 12000 });
|
|
const unmerged = await run("unmerged files", "git diff --name-only --diff-filter=U", { max_output_tokens: 12000 });
|
|
const diffStat = await run("conflict diff stat", "git diff --cc --stat", { max_output_tokens: 12000 });
|
|
const conflictDiff = await run("conflict diff", "git diff --cc", { max_output_tokens: 30000, textLimit: 20000 });
|
|
const currentPatch = await run("current rebase patch", "git rebase --show-current-patch", { max_output_tokens: 20000, textLimit: 12000 });
|
|
return {
|
|
beforeSha,
|
|
rebaseOutput,
|
|
statusOutput: status.output,
|
|
unmergedFiles: unmerged.output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean),
|
|
diffStat: diffStat.output,
|
|
conflictDiff: truncate(conflictDiff.output, 20000),
|
|
currentPatch: truncate(currentPatch.output, 12000),
|
|
interventionPrompt: "Continue this same Code Mode thread to resolve the paused rebase. Preserve the fork patch stack, do not abort or reset unless explicitly instructed, then run the configured verification commands."
|
|
};
|
|
}
|
|
|
|
const releaseTag = String(payload.tag || "");
|
|
const version = versionFromTag(releaseTag);
|
|
const packageName = cfg("package_name", "@peezy.tech/codex");
|
|
const targetBranch = cfg("target_branch", "main");
|
|
const upstreamRemote = cfg("upstream_remote", "upstream");
|
|
const upstreamRepoUrl = cfg("upstream_repo_url", "https://github.com/openai/codex.git");
|
|
const cargoTargetDir = (await env(cfg("cargo_target_dir_env", ""))) || cfg("cargo_target_dir", "/tmp/peezy-codex-flow-target");
|
|
const codexRepo = (await env(cfg("codex_repo_env", ""))) || cfg("codex_repo", "");
|
|
const codexRustDir = codexRepo + "/codex-rs";
|
|
const codexBinary = cargoTargetDir + "/debug/codex";
|
|
|
|
if (!releaseTag) {
|
|
finish("failed", "Release payload is missing tag.");
|
|
}
|
|
if (!version) {
|
|
finish("failed", "Could not infer semantic version from release tag " + releaseTag);
|
|
}
|
|
if (!codexRepo) {
|
|
finish("blocked", "No Codex fork checkout configured. Set codex_repo or codex_repo_env in flow.toml.");
|
|
}
|
|
|
|
text([
|
|
"Peezy Codex fork update flow",
|
|
"",
|
|
"Release: " + releaseTag,
|
|
"Version: " + version,
|
|
"Target branch: " + targetBranch,
|
|
"Codex repo: " + codexRepo,
|
|
"Upstream remote: " + upstreamRemote + " -> " + upstreamRepoUrl,
|
|
"Cargo target dir: " + cargoTargetDir
|
|
].join("\n") + "\n");
|
|
|
|
const published = await run("published fork package check", "npm view " + q(packageName + "@" + version) + " version --json", {
|
|
max_output_tokens: 4000
|
|
});
|
|
if (ok(published) && !enabled("force", false)) {
|
|
finish("skipped", packageName + "@" + version + " is already published.");
|
|
}
|
|
|
|
const repoCheck = await run("verify codex repo", "git rev-parse --show-toplevel");
|
|
if (!ok(repoCheck)) {
|
|
finish("failed", "codex repo is not a git checkout", { repoCheck: repoCheck.output });
|
|
}
|
|
|
|
const rustWorkspaceCheck = await run("verify codex Rust workspace", "test -f " + q(codexRustDir + "/Cargo.toml"), {
|
|
max_output_tokens: 4000
|
|
});
|
|
if (!ok(rustWorkspaceCheck)) {
|
|
finish("failed", "codex Rust workspace was not found at the expected codex-rs path.", {
|
|
codexRustDir,
|
|
rustWorkspaceCheck: rustWorkspaceCheck.output
|
|
});
|
|
}
|
|
|
|
const existingRebase = await run(
|
|
"check existing rebase state",
|
|
"test -d \"$(git rev-parse --git-path rebase-merge)\" -o -d \"$(git rev-parse --git-path rebase-apply)\"",
|
|
{ max_output_tokens: 4000 }
|
|
);
|
|
if (existingRebase.exit_code === 0) {
|
|
const context = await collectRebaseContext("A rebase was already in progress before this flow started.", undefined);
|
|
finish("blocked", "A rebase is already in progress in the Codex checkout.", context);
|
|
}
|
|
|
|
await run("codex status before update", "git status --short --branch", { max_output_tokens: 12000 });
|
|
const branch = await run("current branch", "git rev-parse --abbrev-ref HEAD", { max_output_tokens: 4000 });
|
|
if (!ok(branch)) {
|
|
finish("failed", "could not read current branch", { branchOutput: branch.output });
|
|
}
|
|
|
|
if (trim(branch.output) !== targetBranch) {
|
|
const dirtyBeforeSwitch = await run("dirty check before branch switch", "git status --porcelain=v1", { max_output_tokens: 12000 });
|
|
if (trim(dirtyBeforeSwitch.output)) {
|
|
finish("blocked", "codex checkout has local changes before switching branches.", {
|
|
dirtyStatus: dirtyBeforeSwitch.output
|
|
});
|
|
}
|
|
const switched = await run("switch target branch", "git switch " + q(targetBranch), { max_output_tokens: 12000 });
|
|
if (!ok(switched)) {
|
|
finish("failed", "could not switch to target branch", { switchOutput: switched.output });
|
|
}
|
|
}
|
|
|
|
const dirty = await run("dirty check on target branch", "git status --porcelain=v1", { max_output_tokens: 12000 });
|
|
if (trim(dirty.output)) {
|
|
finish("blocked", "codex target branch has local changes. Resolve or stash them before updating.", {
|
|
dirtyStatus: dirty.output
|
|
});
|
|
}
|
|
|
|
const remote = await run(
|
|
"ensure upstream openai/codex remote",
|
|
"git remote get-url " + q(upstreamRemote) + " >/dev/null 2>&1 && git remote set-url " + q(upstreamRemote) + " " + q(upstreamRepoUrl) + " || git remote add " + q(upstreamRemote) + " " + q(upstreamRepoUrl),
|
|
{ max_output_tokens: 12000 }
|
|
);
|
|
if (!ok(remote)) {
|
|
finish("failed", "could not configure upstream remote", { remoteOutput: remote.output });
|
|
}
|
|
|
|
const fetch = await run("fetch upstream tags", "git fetch " + q(upstreamRemote) + " --tags --prune", {
|
|
max_output_tokens: 20000
|
|
});
|
|
if (!ok(fetch)) {
|
|
finish("failed", "could not fetch upstream release tags", { fetchOutput: fetch.output });
|
|
}
|
|
|
|
const releaseCommit = await run("resolve release tag", "git rev-parse --verify " + q("refs/tags/" + releaseTag + "^{commit}"), {
|
|
max_output_tokens: 4000
|
|
});
|
|
if (!ok(releaseCommit)) {
|
|
finish("failed", "could not resolve upstream release tag after fetch", {
|
|
releaseTag,
|
|
resolveOutput: releaseCommit.output
|
|
});
|
|
}
|
|
|
|
const beforeHead = await run("codex head before rebase", "git rev-parse HEAD", { max_output_tokens: 4000 });
|
|
const rebase = await run("rebase target branch onto upstream release", "git rebase " + q(releaseTag), {
|
|
max_output_tokens: 30000,
|
|
textLimit: 20000
|
|
});
|
|
if (!ok(rebase)) {
|
|
const context = await collectRebaseContext(rebase.output, trim(beforeHead.output));
|
|
finish("needs_intervention", "Rebase paused with conflicts.", context);
|
|
}
|
|
|
|
if (enabled("squash_patch_stack", true)) {
|
|
const count = await run("count fork patch commits", "git rev-list --count " + q(releaseTag) + "..HEAD", {
|
|
max_output_tokens: 4000
|
|
});
|
|
const commitCount = Number(trim(count.output));
|
|
if (Number.isFinite(commitCount) && commitCount > 1) {
|
|
const reset = await run("squash patch stack reset", "git reset --soft " + q(releaseTag), { max_output_tokens: 12000 });
|
|
if (!ok(reset)) {
|
|
finish("failed", "could not soft reset patch stack for squashing", { resetOutput: reset.output });
|
|
}
|
|
const commit = await run("squash patch stack commit", "git commit -m " + q("peezy: codex fork patches for " + releaseTag), {
|
|
max_output_tokens: 20000
|
|
});
|
|
if (!ok(commit)) {
|
|
finish("failed", "could not commit squashed patch stack", { commitOutput: commit.output });
|
|
}
|
|
}
|
|
}
|
|
|
|
const afterHead = await run("codex head after rebase", "git rev-parse HEAD", { max_output_tokens: 4000 });
|
|
await run("codex status after rebase", "git status --short --branch", { max_output_tokens: 12000 });
|
|
|
|
const build = await run(
|
|
"build fork binary",
|
|
"CARGO_TARGET_DIR=" + q(cargoTargetDir) + " cargo build -p codex-cli --bin codex",
|
|
{ workdir: codexRustDir, max_output_tokens: 30000, textLimit: 20000 }
|
|
);
|
|
if (!ok(build)) {
|
|
finish("failed", "fork binary build failed", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
buildOutput: build.output
|
|
});
|
|
}
|
|
|
|
const versionCheck = await run("verify fork binary", q(codexBinary) + " --version", { max_output_tokens: 4000 });
|
|
if (!ok(versionCheck)) {
|
|
finish("failed", "built fork binary did not run", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
versionOutput: versionCheck.output
|
|
});
|
|
}
|
|
|
|
const cargoCheck = await run(
|
|
"cargo check code mode packages",
|
|
"CARGO_TARGET_DIR=" + q(cargoTargetDir) + " cargo check -p codex-app-server -p codex-core -p codex-app-server-protocol",
|
|
{ workdir: codexRustDir, max_output_tokens: 30000, textLimit: 20000 }
|
|
);
|
|
if (!ok(cargoCheck)) {
|
|
finish("failed", "cargo check failed after rebase", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
cargoCheckOutput: cargoCheck.output
|
|
});
|
|
}
|
|
|
|
const protocolTest = await run(
|
|
"protocol code mode execute test",
|
|
"CARGO_TARGET_DIR=" + q(cargoTargetDir) + " cargo test -p codex-app-server-protocol thread_code_mode_execute -- --nocapture",
|
|
{ workdir: codexRustDir, max_output_tokens: 30000, textLimit: 20000 }
|
|
);
|
|
if (!ok(protocolTest)) {
|
|
finish("failed", "protocol Code Mode API test failed after rebase", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
protocolTestOutput: protocolTest.output
|
|
});
|
|
}
|
|
|
|
const fmt = await run("cargo fmt check", "cargo fmt --check", {
|
|
workdir: codexRustDir,
|
|
max_output_tokens: 20000
|
|
});
|
|
if (!ok(fmt)) {
|
|
finish("failed", "cargo fmt --check failed after rebase", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
fmtOutput: fmt.output
|
|
});
|
|
}
|
|
|
|
const diffCheck = await run("codex diff whitespace check", "git diff --check", { max_output_tokens: 12000 });
|
|
if (!ok(diffCheck)) {
|
|
finish("failed", "codex git diff --check failed after rebase", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
diffCheckOutput: diffCheck.output
|
|
});
|
|
}
|
|
|
|
if (enabled("push", false)) {
|
|
const push = await run("push fork branch", "git push origin HEAD:" + q(targetBranch) + " --force-with-lease", {
|
|
max_output_tokens: 20000
|
|
});
|
|
if (!ok(push)) {
|
|
finish("failed", "could not push rebased fork branch", { pushOutput: push.output });
|
|
}
|
|
}
|
|
|
|
if (enabled("publish", false)) {
|
|
const tagCommand = "git tag -a " + q("rust-v" + version) + " -m " + q("Release " + version);
|
|
const tag = await run("create release tag", tagCommand, { max_output_tokens: 12000 });
|
|
if (!ok(tag)) {
|
|
finish("failed", "could not create release tag", { tagOutput: tag.output });
|
|
}
|
|
const pushTag = await run("push release tag", "git push origin " + q("rust-v" + version), {
|
|
max_output_tokens: 20000
|
|
});
|
|
if (!ok(pushTag)) {
|
|
finish("failed", "could not push release tag", { pushTagOutput: pushTag.output });
|
|
}
|
|
}
|
|
|
|
const finalStatus = await run("final codex status", "git status --short --branch", { max_output_tokens: 12000 });
|
|
finish("changed", "Peezy Codex fork rebased onto upstream release and verified.", {
|
|
beforeSha: trim(beforeHead.output),
|
|
afterSha: trim(afterHead.output),
|
|
codexHead: trim(afterHead.output),
|
|
codexBinary,
|
|
codexVersion: trim(versionCheck.output),
|
|
finalStatus: finalStatus.output,
|
|
pushed: enabled("push", false),
|
|
published: enabled("publish", false)
|
|
});
|