@agentbridge1/cli 0.0.1

package/dist/commands/verify.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerify = runVerify;
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const error_catalog_1 = require("../error-catalog");
+const session_state_1 = require("../session-state");
+const server_sync_1 = require("../server-sync");
+const file_fingerprints_1 = require("../file-fingerprints");
+const git_status_1 = require("../git-status");
+const operator_snapshot_1 = require("../operator-snapshot");
+const work_context_resolver_1 = require("../work-context-resolver");
+const verification_conditions_1 = require("../verification-conditions");
+const MAX_EXCERPT_CHARS = 8000;
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId || !apiKey) {
+        throw (0, errors_1.catalogCliError)("CONFIG_INCOMPLETE");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+function excerpt(text) {
+    if (text.length <= MAX_EXCERPT_CHARS)
+        return text;
+    return text.slice(-MAX_EXCERPT_CHARS);
+}
+function currentGitHead() {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function normalizeChangedFiles(files) {
+    return [...new Set(files.map((file) => file.trim()).filter((file) => file.length > 0))].sort();
+}
+function repoDirtySnapshot() {
+    return (0, git_status_1.repoDirtySnapshotFromGitStatus)();
+}
+async function preflightSyncLocalChangedFiles(ctx, workSessionId) {
+    const state = (0, session_state_1.readSessionState)();
+    if (!state)
+        return [];
+    const changedFiles = normalizeChangedFiles(state.changedFiles ?? []);
+    if (changedFiles.length === 0)
+        return [];
+    const fingerprints = (0, file_fingerprints_1.computeFileFingerprints)(changedFiles);
+    const fpMap = new Map(fingerprints.map((fp) => [fp.path, fp.sha256 ?? fp.mtimeMs?.toString() ?? ""]));
+    const nextHash = changedFiles.map((f) => `${f}:${fpMap.get(f) ?? ""}`).join("\n");
+    if (state.lastSyncedChangedFilesHash !== nextHash) {
+        await (0, server_sync_1.postObservedDiff)(ctx, { workSessionId }, {
+            activeLaneDomain: state.laneDomain ?? null,
+            changedFiles,
+            boundaryCrossings: [],
+            fileFingerprints: fingerprints,
+        });
+        state.lastSyncedChangedFilesHash = nextHash;
+        (0, session_state_1.writeSessionState)(state);
+    }
+    return changedFiles;
+}
+async function execute(command) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(command, {
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ exitCode: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (err) => {
+            stderr += `${err instanceof Error ? err.message : String(err)}\n`;
+            resolve({ exitCode: 1, stdout, stderr });
+        });
+    });
+}
+function renderProtocolWarnings(warnings) {
+    if (warnings.length === 0)
+        return [];
+    return [
+        "Protocol warnings:",
+        ...warnings.map((warning) => `- ${warning.code}: ${warning.message}`),
+    ];
+}
+async function runVerify(commandInput, options = {}) {
+    process.exitCode = 0;
+    const command = commandInput.trim();
+    if (!command) {
+        throw (0, errors_1.catalogCliError)("VERIFY_COMMAND_REQUIRED");
+    }
+    const ctx = resolveNetworkContext();
+    const resolution = await (0, work_context_resolver_1.resolveWorkContext)(ctx, {
+        useConfigActiveChangeRequestId: false,
+        includeOtherActiveSessions: true,
+    });
+    if (resolution.state !== "current_session_resolved" || !resolution.binding) {
+        const workContextErr = (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
+        if (options.json) {
+            const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+            process.stdout.write(`${JSON.stringify({
+                snapshot,
+                verification_recorded: false,
+                next_action: [
+                    'run agentbridge start --summary "<work>" --scope "<path>"',
+                    "run agentbridge watch --allow-dirty",
+                ],
+            }, null, 2)}\n`);
+            process.stderr.write(`${(0, errors_1.renderCliError)(workContextErr)}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        process.stdout.write(`${[
+            ...(0, work_context_resolver_1.renderWorkContextLines)(resolution),
+            "",
+            "Verification was not recorded.",
+            "",
+            "Next action:",
+            '- run agentbridge start --summary "<work>" --scope "<path>"',
+            "- or run agentbridge watch --allow-dirty",
+        ].join("\n")}\n`);
+        process.stderr.write(`${(0, errors_1.renderCliError)(workContextErr)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const { workSessionId } = (0, work_context_resolver_1.requireWorkContextBinding)(resolution, "verify");
+    const startedAt = new Date().toISOString();
+    const run = await execute(command);
+    const finishedAt = new Date().toISOString();
+    const status = run.exitCode === 0 ? "passed" : "failed";
+    let localSessionChangedFiles = [];
+    try {
+        localSessionChangedFiles = await preflightSyncLocalChangedFiles(ctx, workSessionId);
+    }
+    catch {
+        localSessionChangedFiles = [];
+    }
+    let acceptanceChangedFiles = [];
+    try {
+        const report = await (0, server_sync_1.fetchAcceptanceCheck)(ctx, { workSessionId });
+        acceptanceChangedFiles = normalizeChangedFiles(report.changed_files ?? []);
+    }
+    catch {
+        acceptanceChangedFiles = [];
+    }
+    const dirtySnapshot = repoDirtySnapshot();
+    const proofScopeFiles = acceptanceChangedFiles.length > 0
+        ? acceptanceChangedFiles
+        : localSessionChangedFiles.length > 0
+            ? localSessionChangedFiles
+            : dirtySnapshot;
+    const proofScopeSource = acceptanceChangedFiles.length > 0
+        ? "acceptance_check"
+        : localSessionChangedFiles.length > 0
+            ? "local_session"
+            : "dirty_snapshot_fallback";
+    const proofScopeFingerprints = (0, file_fingerprints_1.computeFileFingerprints)(proofScopeFiles);
+    const conditions = (0, verification_conditions_1.analyzeVerificationCommand)({
+        command,
+        proofScopeFiles,
+        proofScopeSource,
+        serverBacked: true,
+    });
+    const confidence = (0, verification_conditions_1.buildVerificationConfidence)({ status, conditions });
+    await (0, server_sync_1.postVerificationRun)(ctx, { workSessionId }, {
+        command,
+        startedAt,
+        finishedAt,
+        exitCode: run.exitCode,
+        stdoutExcerpt: excerpt(run.stdout),
+        stderrExcerpt: excerpt(run.stderr),
+        gitHead: currentGitHead(),
+        changedFilesSnapshot: proofScopeFiles,
+        proofScopeFiles,
+        proofScopeSource,
+        repoDirtySnapshot: dirtySnapshot,
+        proofScopeFingerprints,
+        status,
+        conditions,
+        confidence,
+    });
+    let protocolWarnings = [];
+    let latestReport = null;
+    try {
+        const report = await (0, server_sync_1.fetchAcceptanceCheck)(ctx, { workSessionId });
+        latestReport = report;
+        protocolWarnings = report.protocol_warnings ?? [];
+        const warnings = renderProtocolWarnings(protocolWarnings);
+        if (warnings.length > 0) {
+            process.stdout.write(`${warnings.join("\n")}\n`);
+        }
+    }
+    catch {
+        // Verification recording is authoritative; warning fetch is best-effort.
+    }
+    if (options.json) {
+        const report = latestReport ?? (await (0, server_sync_1.fetchAcceptanceCheck)(ctx, { workSessionId }));
+        const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)({
+            ...resolution,
+            binding: {
+                workSessionId,
+                changeRequestId: report.change_request_id ?? null,
+                report,
+            },
+            resolvedServerSessionId: report.work_session_id,
+            resolvedChangeRequestId: report.change_request_id ?? null,
+        });
+        process.stdout.write(`${JSON.stringify({
+            snapshot,
+            verification: {
+                work_session_id: workSessionId,
+                command,
+                status,
+                exit_code: run.exitCode,
+                proof_scope_source: proofScopeSource,
+                proof_scope_files: proofScopeFiles,
+                confidence,
+                conditions,
+                protocol_warnings: protocolWarnings,
+            },
+        }, null, 2)}\n`);
+        return;
+    }
+    if (status === "passed") {
+        const confidenceLines = (0, verification_conditions_1.renderConfidenceSummary)(confidence);
+        const hygieneWarning = (0, verification_conditions_1.renderMockHygieneWarning)(conditions.mock_hygiene);
+        process.stdout.write([
+            "Verification passed.",
+            `Command: ${command}`,
+            `Attached to run: ${workSessionId}`,
+            ...confidenceLines,
+            ...(hygieneWarning ? [hygieneWarning] : []),
+            "Run agentbridge check to review the watch result.",
+        ].join("\n") + "\n");
+        return;
+    }
+    process.stdout.write([
+        "Verification failed.",
+        `Command: ${command}`,
+        `Exit code: ${run.exitCode}`,
+        `Attached to run: ${workSessionId}`,
+        "Run agentbridge check to review failed proof.",
+    ].join("\n") + "\n");
+    process.stderr.write(`${(0, errors_1.renderCliError)((0, errors_1.catalogCliError)("VERIFY_COMMAND_FAILED", {
+        what: `Verification command "${command}" failed with exit code ${run.exitCode}.`,
+    }))}\n`);
+    process.exitCode = 1;
+}

package/dist/commands/version.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVersion = runVersion;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const dist_freshness_1 = require("./dist-freshness");
+function cliRootFromCommandDir() {
+    // src/commands/version.ts -> cli/
+    return (0, node_path_1.resolve)(__dirname, "..", "..");
+}
+function runVersion(cliRootOverride) {
+    const cliRoot = cliRootOverride ?? cliRootFromCommandDir();
+    const packageJsonPath = (0, node_path_1.resolve)(cliRoot, "package.json");
+    const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+    const freshness = (0, dist_freshness_1.getDistFreshnessReport)(cliRoot);
+    const lines = [];
+    lines.push(`agentbridge cli ${pkg?.version ? `v${pkg.version}` : "(version unknown)"}`);
+    lines.push(`CLI dist: ${freshness.state}`);
+    lines.push(`Build timestamp: ${freshness.builtAt ?? "unknown"}`);
+    lines.push(`Git head: ${freshness.gitHead ?? "unknown"}`);
+    lines.push(`Source newer than dist: ${freshness.sourceNewerThanDist}`);
+    if (freshness.sourceLatestFile || freshness.sourceLatestMtime) {
+        lines.push(`Built from source snapshot: ${freshness.sourceLatestFile ?? "unknown"} @ ${freshness.sourceLatestMtime ?? "unknown"}`);
+    }
+    if (freshness.reason) {
+        lines.push(`Reason: ${freshness.reason}`);
+    }
+    if (freshness.state === "stale") {
+        lines.push("CLI dist appears stale. Run: npm run build:cli");
+    }
+    process.stdout.write(`${lines.join("\n")}\n`);
+}