@agentbridge1/cli 0.0.5 → 0.0.7

package/dist/commands/recover.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRecover = runRecover;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
 const config_1 = require("../config");
 const errors_1 = require("../errors");
-const server_sync_1 = require("../server-sync");
-const node_process_1 = require("node:process");
 const gates_1 = require("../gates");
-const init_1 = require("../init");
 const http_1 = require("../http");
+const init_1 = require("../init");
+const recovery_reconcile_1 = require("../recovery-reconcile");
+const server_sync_1 = require("../server-sync");
 function resolveNetworkContext() {
     const cfg = (0, config_1.readConfig)();
     const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "";
@@ -20,9 +23,14 @@ function resolveNetworkContext() {
     }
     return { projectId, apiKey, apiBaseUrl };
 }
+function rulesInstalled(repoRoot) {
+    return ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, "AGENTBRIDGE.md")) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, ".cursor", "rules", "agentbridge.mdc")));
+}
 function renderRecoverOutput(packet) {
     const lines = [];
-    const domainCount = packet.domains_summary.length;
+    const activeDomains = (packet.domains_summary ?? []).filter((d) => d.state !== "retired");
+    const domainCount = activeDomains.length;
     const ruleCount = packet.global_rules?.length ?? 0;
     const hasCharterContext = Boolean(packet.charter_summary?.purpose);
     lines.push("Project recovered.");
@@ -36,7 +44,7 @@ function renderRecoverOutput(packet) {
     if (domainCount > 0) {
         lines.push("");
         lines.push("Domains found:");
-        for (const domain of packet.domains_summary) {
+        for (const domain of activeDomains) {
             const pathNote = domain.owned_path_count > 0 ? `${domain.owned_path_count} path(s)` : "paths pending";
             lines.push(`- ${domain.domain_name} — ${pathNote}`);
         }
@@ -55,18 +63,56 @@ function renderRecoverOutput(packet) {
     }
     lines.push("");
     lines.push("Next:");
-    lines.push("  agentbridge start");
+    lines.push("  agentbridge watch");
     lines.push("");
     return lines.join("\n");
 }
 function recoveryStatusLabel(packet) {
     return packet.recovery_status ?? "unknown";
 }
-function baselineRequired(packet) {
-    const status = packet.recovery_status ?? null;
-    if (packet.project_mode !== "recovery")
-        return false;
-    return status === "baseline_required" || status === "pending" || status === null;
+function formatDomainLines(refs) {
+    if (refs.length === 0)
+        return "  (none)";
+    return refs.map((d) => `- ${d.name}`).join("\n");
+}
+function renderReconcileReport(input) {
+    const { plan, applied, qualityAfter } = input;
+    const lines = [""];
+    if (applied) {
+        lines.push("AgentBridge checked recovery.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+        if (plan.toAdd.length > 0) {
+            lines.push("");
+            lines.push("Added:");
+            lines.push(formatDomainLines(plan.toAdd));
+        }
+        if (plan.toPreserve.length > 0) {
+            lines.push("");
+            lines.push("Existing domains preserved:");
+            lines.push(formatDomainLines(plan.toPreserve));
+        }
+        if (plan.toRetire.length > 0) {
+            lines.push("");
+            lines.push("Retired:");
+            lines.push(formatDomainLines(plan.toRetire));
+        }
+    }
+    else {
+        lines.push("AgentBridge checked recovery.");
+        lines.push("No changes needed.");
+        lines.push("Recovery is up to date.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+    }
+    return lines.join("\n") + "\n";
+}
+function renderBasicHint() {
+    return [
+        "",
+        "Recovery: basic",
+        "AgentBridge found only a generic project area.",
+        "Run `agentbridge recover --force` to rebuild the domain map.",
+        "",
+    ].join("\n");
 }
 function renderRecoveryStatusBlock(input) {
     const lines = [];
@@ -100,7 +146,18 @@ function normalizeBootstrapError(error) {
         return (0, errors_1.catalogCliError)("CONFIG_INCOMPLETE", {
             what: `Recovery bootstrap payload was rejected by server validation${detailText}.`,
             why: "The server cannot activate recovery until required bootstrap fields pass validation.",
-            next: "Retry `agentbridge recover`. If it fails again, run with AGENTBRIDGE_DEBUG=1 and share output.",
+            next: "Retry `agentbridge recover`. If it fails again, run with AGENTBRIDGE_DEBUG_HTTP=1 and share output.",
+        });
+    }
+    if ((0, http_1.isCliHttpError)(error) && error.status >= 500) {
+        const parsed = (0, http_1.parseCliHttpErrorBody)(error);
+        const serverDetail = (0, http_1.extractHttpErrorCode)(parsed) ||
+            error.body.trim().slice(0, 240) ||
+            "no response body";
+        return (0, errors_1.catalogCliError)("SERVER_ERROR", {
+            what: `Recovery bootstrap failed with HTTP ${error.status}.`,
+            why: "The server errored while applying recovery baseline at POST /v1/dev/projects/{id}/bootstrap.",
+            next: `Retry agentbridge recover. For full request/response traces, run with AGENTBRIDGE_DEBUG_HTTP=1. Server detail: ${serverDetail}`,
         });
     }
     if (error instanceof Error) {
@@ -175,15 +232,42 @@ async function runRecover(options = {}) {
         return;
     }
     const beforePacket = packet;
-    const needsRecovery = baselineRequired(beforePacket);
-    let actionTaken = "baseline already exists; no rebuild needed";
-    if (needsRecovery || options.force) {
-        actionTaken = needsRecovery
+    const cfg = (0, config_1.readConfig)();
+    const repoRoot = (0, node_process_1.cwd)();
+    const rulesOk = rulesInstalled(repoRoot);
+    let scan;
+    try {
+        process.stdout.write("Scanning repository layout...\n");
+        scan = await (0, init_1.scanRecoveryFromRepo)(ctx);
+    }
+    catch (error) {
+        process.stderr.write(`${(0, errors_1.renderCliError)(normalizeBootstrapError(error))}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const existingActive = (0, recovery_reconcile_1.packetDomainsToRefs)(beforePacket, cfg.domains ?? []);
+    const plan = (0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive,
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: beforePacket,
+        rulesInstalled: rulesOk,
+    });
+    const needsBaseline = (0, recovery_reconcile_1.recoveryBaselineRequired)(beforePacket);
+    const shouldApply = needsBaseline || options.force || plan.hasChanges;
+    let actionTaken = "reconciliation check only; no changes needed";
+    if (shouldApply) {
+        actionTaken = needsBaseline
             ? "build recovery baseline from repository evidence"
-            : "force-refresh recovery baseline from repository evidence";
-        process.stdout.write("Building recovery baseline now...\n");
+            : options.force
+                ? "force-refresh recovery baseline from repository evidence"
+                : "reconcile recovery with repository evidence";
+        process.stdout.write("Applying recovery changes...\n");
         try {
-            await (0, init_1.runBootstrapRecovery)(ctx);
+            await (0, init_1.runBootstrapRecovery)(ctx, {
+                reconcilePlan: plan,
+                scan,
+            });
             packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
         }
         catch (error) {
@@ -193,7 +277,19 @@ async function runRecover(options = {}) {
         }
     }
     const afterPacket = packet;
-    if (baselineRequired(afterPacket)) {
+    const qualityAfter = (0, recovery_reconcile_1.recoveryQualityLabel)((0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive: (0, recovery_reconcile_1.packetDomainsToRefs)(afterPacket, cfg.domains ?? []),
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: afterPacket,
+        rulesInstalled: rulesOk,
+    }).quality);
+    process.stdout.write(renderReconcileReport({
+        plan,
+        applied: shouldApply,
+        qualityAfter,
+    }));
+    if ((0, recovery_reconcile_1.recoveryBaselineRequired)(afterPacket)) {
         process.stderr.write([
             "Recovery could not complete: baseline still required.",
             "",
@@ -208,7 +304,6 @@ async function runRecover(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const repoRoot = (0, node_process_1.cwd)();
     (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
     (0, gates_1.ensureGatesFile)(repoRoot);
     process.stdout.write(renderRecoveryStatusBlock({
@@ -216,7 +311,10 @@ async function runRecover(options = {}) {
         before: beforePacket,
         after: afterPacket,
         action: actionTaken,
-        next: "agentbridge start",
+        next: "agentbridge watch",
     }));
-    process.stdout.write(renderRecoverOutput(packet));
+    process.stdout.write(renderRecoverOutput(afterPacket));
+    if ((0, recovery_reconcile_1.recoveryIsBasicPacket)(afterPacket)) {
+        process.stdout.write(renderBasicHint());
+    }
 }

package/dist/commands/room.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRoomExit = runRoomExit;
+const config_1 = require("../config");
+const session_state_1 = require("../session-state");
+function envOverridesConfig() {
+    const overrides = [];
+    if (process.env.AGENTBRIDGE_PROJECT_ID?.trim()) {
+        overrides.push("AGENTBRIDGE_PROJECT_ID");
+    }
+    if (process.env.AGENTBRIDGE_API_KEY?.trim()) {
+        overrides.push("AGENTBRIDGE_API_KEY");
+    }
+    if (process.env.AGENTBRIDGE_BASE_URL?.trim()) {
+        overrides.push("AGENTBRIDGE_BASE_URL");
+    }
+    return overrides;
+}
+function shouldClearLocalSession(keepSession) {
+    if (keepSession)
+        return false;
+    const state = (0, session_state_1.readSessionState)();
+    if (!state)
+        return false;
+    return state.status === "active" || state.status === "blocked";
+}
+function runRoomExit(options = {}) {
+    const before = (0, config_1.readConfig)();
+    const hadConnection = Boolean(before.projectId || before.apiKey || before.executionSurfaceId || before.activeAgentId);
+    const result = (0, config_1.clearRoomConnection)();
+    const clearedSession = shouldClearLocalSession(Boolean(options.keepSession));
+    if (clearedSession) {
+        (0, session_state_1.clearSessionState)();
+    }
+    const envOverrides = envOverridesConfig();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            action: "room_exit",
+            config_path: config_1.CONFIG_PATH,
+            had_connection: hadConnection,
+            cleared_keys: result.clearedKeys,
+            previous_project_id: result.previousProjectId ?? null,
+            had_api_key: result.hadApiKey,
+            cleared_local_session: clearedSession,
+            env_overrides: envOverrides,
+            preserved: ["domains", "apiBaseUrl", "precommitHookInstalled", "cliPath"],
+        }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write("AgentBridge room exit\n");
+    process.stdout.write("─────────────────────────────────────────\n");
+    if (!hadConnection && result.clearedKeys.length === 0) {
+        process.stdout.write("No saved room connection in .agentbridge/config.json.\n");
+    }
+    else {
+        process.stdout.write("Cleared saved room connection from .agentbridge/config.json.\n");
+        if (result.previousProjectId) {
+            process.stdout.write(`  Project: ${result.previousProjectId}\n`);
+        }
+        if (result.hadApiKey) {
+            process.stdout.write("  API key: removed from config\n");
+        }
+        if (result.clearedKeys.includes("executionSurfaceId")) {
+            process.stdout.write("  Execution surface: removed from config\n");
+        }
+        if (result.clearedKeys.includes("activeAgentId")) {
+            process.stdout.write("  Active agent: removed from config\n");
+        }
+    }
+    if (clearedSession) {
+        process.stdout.write("Cleared active local supervision session (.agentbridge/session.json).\n");
+    }
+    process.stdout.write("\nPreserved: domain map and other recovery data from init/recover.\n");
+    process.stdout.write("Server rules and MCP config on disk are unchanged.\n");
+    if (envOverrides.length > 0) {
+        process.stdout.write(`\nNote: ${envOverrides.join(", ")} still set in your shell — they override config until unset.\n`);
+    }
+    process.stdout.write("\nNext:\n");
+    process.stdout.write("  1. Get a fresh API key at https://agentbridge.dev/dashboard\n");
+    process.stdout.write("  2. agentbridge connect --project <id> --api-key <key>\n");
+    process.stdout.write("  3. agentbridge doctor\n");
+}

package/dist/commands/setup-mcp.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSetupMcp = runSetupMcp;
+const node_path_1 = require("node:path");
 const config_1 = require("../config");
+const mcp_runtime_1 = require("../mcp-runtime");
 const MCP_SERVER_NAME = "agentbridge";
 function standardSnippet(projectId, apiKey, apiBaseUrl) {
     const serverConfig = {
@@ -47,8 +49,27 @@ async function runSetupMcp(options = {}) {
     else {
         process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
     }
+    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    if (!(0, mcp_runtime_1.isMcpRuntimeAvailable)(cliDistDir)) {
+        process.stdout.write([
+            "",
+            "⚠  MCP runtime is missing from this CLI install.",
+            "   `agentbridge mcp` will exit until you reinstall:",
+            "     npm install -g @agentbridge1/cli@latest",
+            "",
+            "   Or point mcp.json at a repo build:",
+            "     node /path/to/AuthAgent/cli/dist/mcp/agentbridge-mcp.js",
+            "",
+        ].join("\n"));
+    }
+    else {
+        process.stdout.write([
+            "",
+            "✓ MCP runtime is bundled with this CLI (`agentbridge mcp` is ready).",
+            "",
+        ].join("\n"));
+    }
     process.stdout.write([
-        "",
         "After saving the config, restart your editor to activate the MCP server.",
         "The MCP server lets your AI assistant call tools like agent_hello, check AgentBridge status, and trigger approvals.",
         "",

package/dist/commands/start.js

@@ -39,9 +39,8 @@ const domain_resolution_1 = require("../domain-resolution");
 const errors_1 = require("../errors");
 const error_catalog_1 = require("../error-catalog");
 const http_1 = require("../http");
-const git_status_1 = require("../git-status");
 const session_1 = require("../session");
-const work_contract_1 = require("../work-contract");
+const session_state_1 = require("../session-state");
 const server_sync_1 = require("../server-sync");
 const work_context_resolver_1 = require("../work-context-resolver");
 const PROMOTION_PLAN = {
@@ -567,84 +566,55 @@ async function executeStartWorkSession(opts) {
         otherSessionIds: [...new Set(otherSessionIds)],
     };
 }
-async function runSmartStart(opts = {}) {
-    const cfg = (0, config_1.readConfig)();
-    await ensureProjectAccess();
-    const ctx = (0, config_1.contextFromConfig)();
-    const explicitAgentId = opts.agentId?.trim();
-    const configuredActiveAgentId = cfg.activeAgentId?.trim();
-    if (!explicitAgentId && !configuredActiveAgentId) {
-        throw (0, errors_1.catalogCliError)("START_MISSING_ACTIVE_AGENT");
-    }
-    const executionSurfaceId = await resolveExecutionSurfaceIdForStart(ctx, opts, cfg.executionSurfaceId);
-    if (!executionSurfaceId) {
-        throw (0, errors_1.catalogCliError)("START_EXECUTION_SURFACE_REQUIRED");
-    }
-    const resolution = await (0, work_context_resolver_1.resolveWorkContext)(ctx, {
-        allowServerCurrentForCr: true,
-        includeOtherActiveSessions: true,
-    });
-    if (resolution.state === "current_session_resolved") {
-        process.stdout.write("Active work session found - entering watch mode.\n");
-        if (!opts.skipWatch) {
-            const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-            await runWatch({ allowDirty: true });
-        }
-        return;
-    }
-    if (resolution.state === "ambiguous_active_sessions") {
-        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
-        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
-    }
-    if (resolution.state === "mismatch" || resolution.state === "stale_orphan_session_detected") {
-        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
-        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
-    }
-    const inferred = (0, work_contract_1.inferWorkContract)({
+function hasActiveLocalRun() {
+    const local = (0, session_state_1.readSessionState)();
+    if (!local)
+        return false;
+    if (local.status !== "active" && local.status !== "blocked")
+        return false;
+    if (!local.id || local.id === "none")
+        return false;
+    return true;
+}
+async function runDefaultStart(opts = {}) {
+    const { runLocalSupervision } = await Promise.resolve().then(() => __importStar(require("../local-supervision")));
+    await runLocalSupervision({
         prompt: opts.prompt,
-        branchName: (0, git_status_1.getBranchName)(),
-        dirtyFiles: (0, git_status_1.getDirtyWorkingTreeFiles)(),
-        activeChangeRequestId: cfg.activeChangeRequestId ?? null,
-    });
-    const draft = {
-        summary: inferred.summary,
-        scope: opts.scope?.trim() || inferred.scope,
-    };
-    const confirmed = await (0, work_contract_1.confirmWorkContract)(draft, {
-        nonInteractive: !process.stdin.isTTY,
-    });
-    if (!confirmed) {
-        process.stdout.write("Cancelled.\n");
-        return;
-    }
-    await executeStartWorkSession({
-        ...opts,
-        summary: confirmed.summary,
-        scope: confirmed.scope,
+        details: opts.details,
+        confirmClose: opts.confirmClose,
     });
-    process.stdout.write("Work session started. Entering watch mode...\n");
-    if (!opts.skipWatch) {
-        const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-        await runWatch({ allowDirty: true });
-    }
+}
+function isStrictTrackedStartRequest(opts) {
+    if (opts.resume === true)
+        return true;
+    if (opts.changeRequestId?.trim())
+        return true;
+    const explicitSummaryFlag = opts.summaryFlagProvided === true;
+    const explicitScopeFlag = opts.scopeFlagProvided === true;
+    const explicitInputProvided = opts.summary !== undefined || opts.scope !== undefined;
+    return explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
 }
 async function runStart(opts = {}) {
+    const strictTrackedStart = isStrictTrackedStartRequest(opts);
     const explicitSummaryFlag = opts.summaryFlagProvided === true;
     const explicitScopeFlag = opts.scopeFlagProvided === true;
     const explicitInputProvided = opts.summary !== undefined || opts.scope !== undefined;
     const explicitModeRequested = explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
     const explicitSummary = opts.summary?.trim();
     const explicitScope = opts.scope?.trim();
-    if (explicitModeRequested && explicitSummary && explicitScope) {
+    if (strictTrackedStart && explicitSummary && explicitScope) {
         await executeStartWorkSession({ ...opts, summary: explicitSummary, scope: explicitScope });
         if (!opts.skipWatch) {
             const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-            await runWatch({ allowDirty: true });
+            await runWatch({ allowDirty: true, details: opts.details });
         }
         return;
     }
+    if (strictTrackedStart) {
+        throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED");
+    }
     if (explicitModeRequested) {
         throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED");
     }
-    await runSmartStart(opts);
+    await runDefaultStart(opts);
 }