aui-agent-builder 0.3.76 → 0.3.78

package/dist/commands/push.js

@@ -11,7 +11,7 @@ import { findAuiFiles, parseAuiFile } from "../utils/index.js";
 import { validate } from "./validate.js";
 import { getTracer, SpanStatusCode, setUserContext } from "../telemetry.js";
 import { getItemLevelDiff } from "../utils/git.js";
-import { AuthenticationError, ConfigError, ValidationError } from "../errors/index.js";
+import { AuthenticationError, CLIError, ConfigError, ValidationError } from "../errors/index.js";
 import { StatusLine, Spinner, ErrorDisplay, Hint, } from "../ui/components/index.js";
 import { colors, icons } from "../ui/theme.js";
 import { PushFileSummary, PushChangesView, PushTaskLine, PushFinalSummary, } from "../ui/views/PushView.js";
@@ -459,15 +459,18 @@ async function _push(pushSpan, agentCode, options = {}) {
         if (savedApiKey && !options.apiKey) {
             client.setAgentSettingsApiKey(savedApiKey);
         }
-        // Only do version management if this project was imported with versioning
-        // (has version_id in .auirc). Old agents without versions push to live scope.
+        // Version management: push is only allowed to draft versions.
+        // If the project has version_id in .auirc or --version-id is passed,
+        // we validate it's a draft. If no version context exists, we auto-detect
+        // available drafts. Push is rejected if no draft is found.
         let prePushDraft = null;
         if (projectConfig.version_id || options.versionId) {
             prePushDraft = await resolveVersionDraft(config, projectConfig, session, options.versionId);
-            if (prePushDraft?.versionId) {
-                agentSettingsParams.version_id = prePushDraft.versionId;
-                log(_jsx(StatusLine, { kind: "info", label: `Pushing into version draft: ${prePushDraft.label}` }));
+            if (!prePushDraft) {
+                return;
             }
+            agentSettingsParams.version_id = prePushDraft.versionId;
+            log(_jsx(StatusLine, { kind: "info", label: `Pushing into draft version: ${prePushDraft.label}` }));
         }
         const pushTasks = buildPushTasks(diff, fileData, projectRoot, getFileDiff);
         pushSpan.setAttribute("push.task_count", pushTasks.length);
@@ -667,33 +670,150 @@ async function _push(pushSpan, agentCode, options = {}) {
         if (pushFailures.length > 0) {
             pushSpan.setAttribute("push.failures", JSON.stringify(pushFailures));
         }
+        // ─── Push Snapshot (last step — after entity push) ───
+        // The snapshot captures the local file state and uploads it as the
+        // source of truth for this push. Runs regardless of entity-push outcomes
+        // so the file history is preserved even on partial DB failures.
+        // Files = source of truth; DB updates are best-effort.
+        //
+        // IMPORTANT: snapshot failures must be loud — they are NOT counted in
+        // the entity `failed` counter, so without explicit surfacing here and
+        // a thrown CLIError at the end of `_push`, a snapshot failure would
+        // be hidden behind the "All N change(s) pushed successfully" summary
+        // and the process would exit 0.
+        // Retry policy: snapshot upload is the source-of-truth step; transient
+        // failures (network blips, 5xx, timeouts) are common with multipart
+        // uploads, so we retry up to 3 times with exponential backoff (1s, 2s,
+        // 4s) before giving up. 4xx responses are still retried — keeping the
+        // policy dumb here mirrors the single retry already in the api-client
+        // layer for entity pushes.
+        let snapshotSucceeded = false;
+        let snapshotError;
+        let snapshotAttempts = 0;
+        if (prePushDraft) {
+            const SNAPSHOT_MAX_ATTEMPTS = 4;
+            const SNAPSHOT_RETRY_BASE_MS = 1000;
+            for (let attempt = 1; attempt <= SNAPSHOT_MAX_ATTEMPTS; attempt++) {
+                snapshotAttempts = attempt;
+                const label = attempt === 1
+                    ? "Pushing snapshot (file state)..."
+                    : `Retrying snapshot push (attempt ${attempt}/${SNAPSHOT_MAX_ATTEMPTS})...`;
+                if (json)
+                    stderrLog(label);
+                const snapshotSpinner = json ? null : startSpinner(label);
+                let attemptError;
+                try {
+                    const snapshotResult = await pushSnapshot(client, prePushDraft.agentId, prePushDraft.versionId, projectRoot, fileData);
+                    if (snapshotResult.success) {
+                        const okMsg = attempt === 1
+                            ? `Snapshot pushed (${fileData.length} file(s))`
+                            : `Snapshot pushed (${fileData.length} file(s), attempt ${attempt}/${SNAPSHOT_MAX_ATTEMPTS})`;
+                        if (snapshotSpinner)
+                            snapshotSpinner.succeed(okMsg);
+                        else
+                            stderrLog(okMsg);
+                        snapshotSucceeded = true;
+                        snapshotError = undefined;
+                        break;
+                    }
+                    attemptError = snapshotResult.error || "Unknown snapshot error";
+                }
+                catch (error) {
+                    attemptError = error instanceof Error ? error.message : String(error);
+                }
+                snapshotError = attemptError;
+                const isLast = attempt === SNAPSHOT_MAX_ATTEMPTS;
+                const failMsg = isLast
+                    ? `Snapshot push failed after ${attempt} attempt(s): ${attemptError}`
+                    : `Snapshot push failed (attempt ${attempt}/${SNAPSHOT_MAX_ATTEMPTS}): ${attemptError}`;
+                if (snapshotSpinner)
+                    snapshotSpinner.fail(failMsg);
+                else
+                    stderrLog(failMsg);
+                if (isLast)
+                    break;
+                const delayMs = SNAPSHOT_RETRY_BASE_MS * Math.pow(2, attempt - 1);
+                if (json)
+                    stderrLog(`Waiting ${delayMs}ms before retry...`);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+            pushSpan.setAttribute("push.snapshot.success", snapshotSucceeded);
+            pushSpan.setAttribute("push.snapshot.attempts", snapshotAttempts);
+            if (!snapshotSucceeded && snapshotError) {
+                pushSpan.setAttribute("push.snapshot.error", snapshotError);
+            }
+        }
+        const snapshotStatus = prePushDraft
+            ? snapshotSucceeded
+                ? "succeeded"
+                : "failed"
+            : undefined;
         const memoryPath = writePushMemory(projectRoot, agentCodeStr, agentIdStr, pushTasks, succeededFiles, pushFailures);
+        // ─── Baseline Update ───
+        // Only commit baseline if snapshot succeeded (or no draft = legacy mode).
+        // This ensures: if snapshot fails, user re-runs `aui push` to retry both
+        // failed entity pushes AND the snapshot. Local files remain the source
+        // of truth until the server has captured them.
         let baselineUpdated = false;
-        if (failed > 0 && succeeded > 0) {
-            if (succeededFiles.length > 0) {
-                commitBaselineFiles(projectRoot, succeededFiles, `pushed ${succeeded} change(s)`);
+        const canCommitBaseline = !prePushDraft || snapshotSucceeded;
+        if (canCommitBaseline) {
+            if (failed > 0 && succeeded > 0) {
+                if (succeededFiles.length > 0) {
+                    commitBaselineFiles(projectRoot, succeededFiles, `pushed ${succeeded} change(s)`);
+                    baselineUpdated = true;
+                }
+            }
+            else if (failed === 0) {
+                commitBaseline(projectRoot, "pushed changes");
                 baselineUpdated = true;
             }
         }
-        else if (failed === 0) {
-            commitBaseline(projectRoot, "pushed changes");
-            baselineUpdated = true;
+        log(_jsx(PushFinalSummary, { succeeded: succeeded, failed: failed, baselineUpdated: baselineUpdated, logDir: logRelPath, memoryPath: memoryPath, snapshotStatus: snapshotStatus, snapshotError: snapshotError }));
+        if (failed > 0) {
+            log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "warning", label: `${failed} entity change(s) failed to push to DB.` }), pushFailures.map((f) => (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Text, { color: "red", children: ["  ", icons.error, " ", f.label] }), _jsxs(Text, { color: colors.muted, children: ["    Error: ", f.error] }), f.file && _jsxs(Text, { color: colors.muted, children: ["    File: ", f.file] })] }, f.label))), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.info, bold: true, children: "What to do next: " }), _jsxs(Text, { color: colors.muted, children: ["Fix the issues above and re-run ", _jsx(Text, { bold: true, children: "aui push" }), " to retry the failed changes."] })] })] }));
         }
-        log(_jsx(PushFinalSummary, { succeeded: succeeded, failed: failed, baselineUpdated: baselineUpdated, logDir: logRelPath, memoryPath: memoryPath }));
+        // ─── Snapshot result message ───
         if (prePushDraft) {
-            log(_jsx(StatusLine, { kind: "info", label: `Changes pushed into draft ${prePushDraft.label}. Run: aui version publish → aui version activate` }));
+            if (!snapshotSucceeded) {
+                log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "error", label: `Snapshot upload failed${snapshotError ? `: ${snapshotError}` : ""}` }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.info, bold: true, children: "What to do next: " }), _jsxs(Text, { color: colors.muted, children: ["Re-run ", _jsx(Text, { bold: true, children: "aui push" }), " to retry the snapshot. Your local files are the source of truth \u2014 they remain unchanged."] })] })] }));
+            }
+            else if (failed === 0) {
+                log(_jsx(StatusLine, { kind: "info", label: `All changes pushed into draft ${prePushDraft.label}. Run: aui version publish → aui version activate` }));
+            }
+            else {
+                log(_jsx(StatusLine, { kind: "warning", label: `Snapshot saved for draft ${prePushDraft.label}, but ${failed} DB update(s) failed. Re-run "aui push" to retry the DB updates before publishing.` }));
+            }
         }
+        const snapshotFailed = snapshotStatus === "failed";
         pushSpan.setAttribute("push.exit_reason", failed > 0
             ? succeeded > 0
                 ? "partial_failure"
                 : "failed"
-            : "completed");
+            : snapshotFailed
+                ? "snapshot_failed"
+                : "completed");
         pushSpan.setAttribute("push.succeeded_count", succeeded);
         pushSpan.setAttribute("push.failed_count", failed);
+        // Snapshot failure must propagate as a non-zero exit code. Without this
+        // throw, `failed === 0` would let the command exit 0 and CI/CD would
+        // never notice the snapshot upload failed. handleError() also produces
+        // a structured JSON envelope when --json is set.
+        if (snapshotFailed) {
+            throw new CLIError(`Snapshot upload failed${snapshotError ? `: ${snapshotError}` : ""}`, {
+                suggestion: "Re-run `aui push` to retry the snapshot. Your local files are the source of truth — they remain unchanged.",
+            });
+        }
     }
     catch (error) {
         if (spinner)
             spinner.fail("Push failed");
+        // CLIErrors carry actionable info and a meaningful exit code — let
+        // handleError() format them and exit non-zero. Without this re-throw
+        // a snapshot-failure CLIError thrown above would be swallowed in TUI
+        // mode and the process would exit 0.
+        if (error instanceof CLIError) {
+            throw error;
+        }
         if (!json)
             log(_jsx(ErrorDisplay, { error: error }));
         else
@@ -711,110 +831,133 @@ async function resolveVersionDraft(config, projectConfig, session, explicitVersi
     const key = loadAgentSettingsApiKey();
     if (key)
         client.setAgentSettingsApiKey(key);
-    // If user passed --version-id, use it directly
-    if (explicitVersionId) {
+    let agentInfo;
+    const agentMgmtId = session.agent_management_id;
+    // Project's network_id (from .auirc) takes priority over session — when
+    // you're inside a project, that's the agent you mean. Session agent may
+    // point at a different agent (e.g. last `aui agents --switch`).
+    const projectNetworkId = projectConfig.agent_id;
+    const fallbackNetworkId = session.network_id;
+    if (projectNetworkId) {
         try {
-            const agentMgmtId = session.agent_management_id;
-            if (agentMgmtId) {
-                const ver = await client.agentManagement.getVersion(agentMgmtId, explicitVersionId);
-                const label = `v${ver.version_number}.${ver.version_revision_number}`;
-                return { versionId: ver.id, label };
-            }
+            const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: projectNetworkId });
+            agentInfo = resp.items.find((a) => a.scope.network_id === projectNetworkId || a.id === projectNetworkId);
         }
         catch {
-            // fall through
+            // listing failed, fall through
         }
-        return { versionId: explicitVersionId, label: explicitVersionId.slice(0, 10) };
     }
-    let agentInfo;
-    const agentMgmtId = session.agent_management_id;
-    const networkId = projectConfig.agent_id || session.network_id;
-    if (agentMgmtId) {
+    // Fall back to session's agent_management_id only when not inside a project
+    if (!agentInfo && !projectNetworkId && agentMgmtId) {
         try {
             agentInfo = await client.agentManagement.getAgent(agentMgmtId);
         }
         catch {
-            // stale ID
+            // stale ID, fall through
         }
     }
-    if (!agentInfo && networkId) {
+    // Last resort: session's network_id
+    if (!agentInfo && fallbackNetworkId) {
         try {
-            const allAgents = [];
-            let page = 1;
-            let hasMore = true;
-            while (hasMore) {
-                const resp = await client.agentManagement.listAgents(client.getOrganizationId(), page, 50);
-                allAgents.push(...resp.items);
-                hasMore = page < resp.pages;
-                page++;
-            }
-            agentInfo = allAgents.find((a) => a.scope.network_id === networkId || a.id === networkId);
+            const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: fallbackNetworkId });
+            agentInfo = resp.items.find((a) => a.scope.network_id === fallbackNetworkId || a.id === fallbackNetworkId);
         }
         catch {
             // no agent-management available
         }
     }
-    if (!agentInfo)
+    if (!agentInfo) {
+        log(_jsx(ErrorDisplay, { message: "Could not resolve agent for version management.", suggestion: "Run `aui import-agent` to link an agent, or check your session with `aui status`." }));
         return null;
+    }
+    // If user passed --version-id, validate it's a draft
+    if (explicitVersionId) {
+        try {
+            const ver = await client.agentManagement.getVersion(agentInfo.id, explicitVersionId);
+            if (ver.status !== "draft") {
+                log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "error", label: `Version v${ver.version_number} is "${ver.status}" — you can only push to a draft version.` }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.info, bold: true, children: "What to do next:" }), _jsxs(Text, { color: colors.muted, children: ["  1. Create a new draft version:  ", _jsx(Text, { bold: true, children: "aui version create" })] }), _jsxs(Text, { color: colors.muted, children: ["  2. Then push with:              ", _jsxs(Text, { bold: true, children: ["aui push --version-id ", '<new-draft-id>'] })] })] })] }));
+                return null;
+            }
+            const label = `v${ver.version_number}`;
+            return { versionId: ver.id, label, agentId: agentInfo.id };
+        }
+        catch (error) {
+            log(_jsx(ErrorDisplay, { message: `Could not fetch version "${explicitVersionId}": ${error instanceof Error ? error.message : String(error)}`, suggestion: "Check the version ID with `aui version list` and try again." }));
+            return null;
+        }
+    }
+    // Resolve from .auirc version_id or auto-detect drafts
     let allVersions = [];
     try {
         const versionsResp = await client.agentManagement.listVersions(agentInfo.id, 1, 50);
         allVersions = versionsResp.items;
     }
     catch {
+        log(_jsx(ErrorDisplay, { message: "Could not fetch versions for this agent.", suggestion: "Check your connection and try again. Use `aui version list` to debug." }));
         return null;
     }
+    // If .auirc has a version_id, validate it's still a draft
+    if (projectConfig.version_id) {
+        const configVersion = allVersions.find((v) => v.id === projectConfig.version_id);
+        if (configVersion) {
+            if (configVersion.status !== "draft") {
+                log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "error", label: `The version in your .auirc (v${configVersion.version_number}) is "${configVersion.status}" — you can only push to a draft version.` }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.info, bold: true, children: "What to do next:" }), _jsxs(Text, { color: colors.muted, children: ["  1. Create a new draft version:  ", _jsx(Text, { bold: true, children: "aui version create" })] }), _jsxs(Text, { color: colors.muted, children: ["  2. Import the new draft:        ", _jsxs(Text, { bold: true, children: ["aui import-agent --version ", '<new-draft-id>'] })] }), _jsxs(Text, { color: colors.muted, children: ["  3. Then push your changes:      ", _jsx(Text, { bold: true, children: "aui push" })] })] })] }));
+                return null;
+            }
+            const label = `v${configVersion.version_number}`;
+            return { versionId: configVersion.id, label, agentId: agentInfo.id };
+        }
+    }
+    // Auto-detect drafts
     const drafts = allVersions.filter((v) => v.status === "draft");
-    const latestPublished = allVersions.find((v) => v.status === "published" || v.status === "archived");
+    if (drafts.length === 0) {
+        log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "error", label: "No draft version found \u2014 you can only push to a draft version." }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.info, bold: true, children: "What to do next:" }), _jsxs(Text, { color: colors.muted, children: ["  1. Create a new draft version:  ", _jsx(Text, { bold: true, children: "aui version create" })] }), _jsxs(Text, { color: colors.muted, children: ["  2. Import the draft:            ", _jsxs(Text, { bold: true, children: ["aui import-agent --version ", '<draft-id>'] })] }), _jsxs(Text, { color: colors.muted, children: ["  3. Then push your changes:      ", _jsx(Text, { bold: true, children: "aui push" })] })] })] }));
+        return null;
+    }
     if (drafts.length === 1) {
         const draft = drafts[0];
-        const label = `v${draft.version_number}.${draft.version_revision_number}`;
-        return { versionId: draft.id, label };
+        const label = `v${draft.version_number}`;
+        return { versionId: draft.id, label, agentId: agentInfo.id };
     }
-    if (drafts.length > 1) {
-        const json = isJsonMode();
-        if (json) {
-            const draft = drafts[0];
-            const label = `v${draft.version_number}.${draft.version_revision_number}`;
-            return { versionId: draft.id, label };
-        }
-        const { selected } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "selected",
-                message: `${drafts.length} drafts found. Push into which draft?`,
-                choices: drafts.map((d) => {
-                    const dl = `v${d.version_number}.${d.version_revision_number}`;
-                    return {
-                        name: `${dl} — ${d.stats?.total ?? "?"} entities ${d.label || ""}`,
-                        value: d,
-                    };
-                }),
-                pageSize: 10,
-            },
-        ]);
-        const chosen = selected;
-        const label = `v${chosen.version_number}.${chosen.version_revision_number}`;
-        return { versionId: chosen.id, label };
+    // Multiple drafts — auto-pick the latest (drafts are sorted DESC by created_at)
+    // No interactive prompt: keeps `aui push` non-blocking. Use --version-id to
+    // explicitly target a different draft.
+    const latest = drafts[0];
+    const latestLabel = `v${latest.version_number}`;
+    if (!isJsonMode()) {
+        log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "info", label: `${drafts.length} drafts found — auto-selecting latest: ${latestLabel}` }), _jsxs(Text, { color: colors.muted, children: ["  Tip: pass ", _jsxs(Text, { bold: true, children: ["--version-id ", '<id>'] }), " to target a specific draft."] })] }));
     }
-    // No drafts — create a revision from latest published, or v1.0 from scope
-    const bumpMode = latestPublished ? "version_revision_number" : "version_number";
-    const versionSpinner = startSpinner("Creating version draft...");
-    try {
-        const draft = await client.agentManagement.createDraft(agentInfo.id, {
-            source: latestPublished ? "version" : "agent-scope",
-            ...(latestPublished ? { from_version: latestPublished.id } : {}),
-            bump_mode: bumpMode,
-            created_by: session.user_id,
+    return { versionId: latest.id, label: latestLabel, agentId: agentInfo.id };
+}
+/**
+ * Push a snapshot of all local agent files to the server via multipart upload.
+ * This captures the current state of the files to maintain version history.
+ * Version bump happens automatically on the server when snapshot succeeds.
+ *
+ * If any files fail, the user must re-run `aui push` to retry.
+ */
+async function pushSnapshot(client, agentId, versionId, projectRoot, fileData) {
+    const filesToUpload = [];
+    for (const fd of fileData) {
+        const fullPath = path.join(projectRoot, fd.file);
+        if (!fs.existsSync(fullPath))
+            continue;
+        const content = fs.readFileSync(fullPath);
+        filesToUpload.push({
+            filePath: fullPath,
+            fileName: path.basename(fd.file),
+            content,
         });
-        const label = `v${draft.version_number}.${draft.version_revision_number}`;
-        versionSpinner.succeed(`Version draft created: ${label}`);
-        return { versionId: draft.id, label };
     }
-    catch (error) {
-        versionSpinner.fail(`Version draft failed: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
+    if (filesToUpload.length === 0) {
+        return { success: true, failed: [] };
     }
+    const result = await client.agentManagement.pushSnapshot(agentId, versionId, filesToUpload);
+    return {
+        success: result.success,
+        failed: result.failed,
+        error: result.error,
+    };
 }
 // ─── Agent Settings Params Resolution ───
 async function resolveAgentSettingsParams(config, projectConfig, session, projectRoot, scopeLevel) {