@agentbridge1/cli 0.0.6 → 0.0.8

package/dist/commands/install-rules.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstallRules = runInstallRules;
+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 http_1 = require("../http");
+const rules_sync_1 = require("../rules-sync");
+function resolveNetworkContext(overrides) {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = overrides.projectId ?? process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "";
+    const apiKey = overrides.apiKey ?? process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = overrides.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 };
+}
+async function runInstallRules(opts = {}) {
+    const ctx = resolveNetworkContext(opts);
+    const workspaceRoot = (0, node_process_1.cwd)();
+    let rules;
+    try {
+        rules = await (0, rules_sync_1.fetchProjectRules)(ctx);
+    }
+    catch (error) {
+        if ((0, http_1.isCliHttpError)(error)) {
+            throw new errors_1.SafeCliError(`Could not fetch AgentBridge rules for project ${ctx.projectId} (${error.status}).`);
+        }
+        throw error;
+    }
+    if (!Array.isArray(rules.files) || rules.files.length === 0) {
+        throw new errors_1.SafeCliError("AgentBridge rules response did not include any files to install.");
+    }
+    (0, rules_sync_1.writeRulesFiles)(workspaceRoot, rules.files);
+    let installedAt = null;
+    try {
+        const marked = await (0, rules_sync_1.markProjectRulesInstalled)(ctx);
+        installedAt = marked.rules_installed_at ?? null;
+    }
+    catch (error) {
+        if ((0, http_1.isCliHttpError)(error)) {
+            throw new errors_1.SafeCliError(`Wrote rules files locally, but could not mark them installed on the server (${error.status}).`);
+        }
+        throw error;
+    }
+    const projectName = (0, rules_sync_1.extractProjectNameFromRulesResponse)(rules.files);
+    const lines = [
+        "Installed AgentBridge protocol rules:",
+        `  Project: ${projectName ?? "(unknown name)"} (${ctx.projectId})`,
+        `  Wrote: ${(0, node_path_1.resolve)(workspaceRoot, "AGENTBRIDGE.md")}`,
+        `  Wrote: ${(0, node_path_1.resolve)(workspaceRoot, ".cursor", "rules", "agentbridge.mdc")}`,
+    ];
+    if (installedAt) {
+        lines.push(`  Server marked installed at: ${installedAt}`);
+    }
+    lines.push("");
+    lines.push("Next: run `agentbridge doctor` to verify rules and MCP configuration.");
+    process.stdout.write(`${lines.join("\n")}\n`);
+}

package/dist/commands/recover.js

@@ -110,7 +110,7 @@ function renderBasicHint() {
         "",
         "Recovery: basic",
         "AgentBridge found only a generic project area.",
-        "Run `agent recover --force` to rebuild the domain map.",
+        "Run `agentbridge recover --force` to rebuild the domain map.",
         "",
     ].join("\n");
 }
@@ -146,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) {

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

@@ -3,72 +3,82 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSetupMcp = runSetupMcp;
 const node_path_1 = require("node:path");
 const config_1 = require("../config");
+const mcp_config_1 = require("../mcp-config");
 const mcp_runtime_1 = require("../mcp-runtime");
 const MCP_SERVER_NAME = "agentbridge";
-function standardSnippet(projectId, apiKey, apiBaseUrl) {
-    const serverConfig = {
-        command: "agentbridge",
-        args: ["mcp"],
-        env: {
-            AGENTBRIDGE_PROJECT_ID: projectId,
-            AGENTBRIDGE_API_KEY: apiKey,
-            AGENTBRIDGE_BASE_URL: apiBaseUrl,
-        },
-    };
-    return JSON.stringify({ [MCP_SERVER_NAME]: serverConfig }, null, 2);
-}
-async function runSetupMcp(options = {}) {
-    const cfg = (0, config_1.readConfig)();
-    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "<your-project-id>";
-    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "<your-api-key>";
-    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??
-        cfg.apiBaseUrl ??
-        "https://agentauth-api-production.up.railway.app";
-    const editor = options.editor ?? "cursor";
-    process.stdout.write("\nAgentBridge MCP Setup\n");
-    process.stdout.write("─────────────────────────────────────────\n\n");
+function editorConfigHint(editor) {
     if (editor === "cursor") {
-        process.stdout.write("Add this to your ~/.cursor/mcp.json (or project-level .cursor/mcp.json):\n\n");
-    }
-    else if (editor === "windsurf") {
-        process.stdout.write("Add this to your ~/.codeium/windsurf/mcp_config.json:\n\n");
-    }
-    else if (editor === "vscode") {
-        process.stdout.write("Add this to your .vscode/mcp.json:\n\n");
-    }
-    else {
-        process.stdout.write(`Add this to your ${editor} MCP config:\n\n`);
+        return "Add this to your ~/.cursor/mcp.json (or project-level .cursor/mcp.json):\n\n";
     }
-    process.stdout.write("Recommended config:\n\n");
-    process.stdout.write(JSON.stringify({
-        mcpServers: JSON.parse(standardSnippet(projectId, apiKey, apiBaseUrl)),
-    }, null, 2) + "\n");
-    if (projectId === "<your-project-id>" || apiKey === "<your-api-key>") {
-        process.stdout.write("\n⚠  Credentials not found. Run `agentbridge connect` first to save your project ID and API key.\n");
+    if (editor === "windsurf") {
+        return "Add this to your ~/.codeium/windsurf/mcp_config.json:\n\n";
     }
-    else {
-        process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
+    if (editor === "vscode") {
+        return "Add this to your .vscode/mcp.json:\n\n";
     }
-    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    return "Add this to your " + editor + " MCP config:\n\n";
+}
+function printRuntimeStatus(cliDistDir) {
     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:",
+            "   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"));
+        return;
     }
-    else {
+    process.stdout.write(["", "✓ MCP runtime is bundled with this CLI (agentbridge mcp is ready).", ""].join("\n"));
+}
+async function runSetupMcp(options = {}) {
+    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    const editor = options.editor ?? "cursor";
+    process.stdout.write("\nAgentBridge MCP Setup\n");
+    process.stdout.write("─────────────────────────────────────────\n\n");
+    if (options.local) {
+        const entry = (0, mcp_config_1.buildLocalMcpServerEntry)(cliDistDir);
+        const mcpPath = (0, mcp_config_1.writeLocalMcpConfig)(cliDistDir);
+        process.stdout.write("Mode: local-first (no project ID or API key required)\n\n");
+        process.stdout.write("MCP config written: " + mcpPath + "\n\n");
+        process.stdout.write("Configured entry:\n\n");
+        process.stdout.write(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: entry } }, null, 2) + "\n");
+        process.stdout.write("\nLocal mode: agent_hello creates work contracts on disk.\n" +
+            "  Run agentbridge watch in this repo, then restart Cursor.\n");
+        printRuntimeStatus(cliDistDir);
         process.stdout.write([
             "",
-            "✓ MCP runtime is bundled with this CLI (`agentbridge mcp` is ready).",
+            "Next:",
+            "  1. Restart Cursor to load MCP.",
+            "  2. agentbridge watch",
+            "  3. In chat: agent_hello({ intent: \"what you are about to do\" })",
             "",
         ].join("\n"));
+        return;
+    }
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "<your-project-id>";
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "<your-api-key>";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??
+        cfg.apiBaseUrl ??
+        "https://agentauth-api-production.up.railway.app";
+    process.stdout.write(editorConfigHint(editor));
+    process.stdout.write("Recommended config:\n\n");
+    const serverEntry = (0, mcp_config_1.buildServerMcpServerEntry)(projectId, apiKey, apiBaseUrl);
+    process.stdout.write(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: serverEntry } }, null, 2) + "\n");
+    if (projectId === "<your-project-id>" || apiKey === "<your-api-key>") {
+        process.stdout.write("\n⚠  Credentials not found. Run agentbridge connect first to save your project ID and API key.\n" +
+            "   Or use local mode: agentbridge setup-mcp --local\n");
+    }
+    else {
+        const mcpPath = (0, mcp_config_1.mergeAgentbridgeIntoCursorMcp)(serverEntry);
+        process.stdout.write("\nMCP config written: " + mcpPath + "\n");
+        process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
     }
+    printRuntimeStatus(cliDistDir);
     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

@@ -33,12 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalStart = runLocalStart;
 exports.runStart = runStart;
 const config_1 = require("../config");
 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 intent_validation_1 = require("../intent-validation");
 const session_1 = require("../session");
 const session_state_1 = require("../session-state");
 const server_sync_1 = require("../server-sync");
@@ -300,10 +302,19 @@ async function resolveStartOwnership(input) {
         projectId: ctx.projectId,
         identities,
     });
-    let resolvedDomain = input.explicitDomain?.trim() ||
-        (0, domain_resolution_1.inferLaneFromFiles)([input.scope], input.configuredDomains).laneDomain ||
+    const explicitDomain = input.explicitDomain?.trim();
+    const inferredScopeDomain = (0, domain_resolution_1.inferLaneFromFiles)([input.scope], input.configuredDomains).laneDomain;
+    let resolvedDomain = explicitDomain ||
+        inferredScopeDomain ||
         callerIdentity.domainName ||
         undefined;
+    let laneClaimSource = explicitDomain
+        ? "explicit_domain"
+        : inferredScopeDomain
+            ? "scope_pattern"
+            : callerIdentity.domainName
+                ? "caller_identity_domain"
+                : "unresolved";
     let packetDomainOwner = null;
     let packetDomainName = null;
     try {
@@ -315,6 +326,7 @@ async function resolveStartOwnership(input) {
         const first = domainPacket.domains[0];
         if (!resolvedDomain && first?.domain_name) {
             resolvedDomain = first.domain_name;
+            laneClaimSource = "domain_packet";
         }
         packetDomainOwner = first?.owner_work_identity_id ?? null;
         packetDomainName = first?.domain_name ?? null;
@@ -325,6 +337,11 @@ async function resolveStartOwnership(input) {
     if (!resolvedDomain) {
         throw (0, errors_1.catalogCliError)("START_DOMAIN_UNRESOLVED");
     }
+    const laneClaimConfidence = laneClaimSource === "explicit_domain" || laneClaimSource === "scope_pattern"
+        ? "high"
+        : laneClaimSource === "domain_packet" || laneClaimSource === "caller_identity_domain"
+            ? "medium"
+            : "low";
     const projectDomain = projectPacket.domains_summary.find((domain) => equalsIgnoreCase(domain.domain_name, resolvedDomain));
     const ownerFromProjectPacket = projectDomain?.owner_work_identity_id ?? null;
     const ownerFromPacket = packetDomainOwner;
@@ -343,6 +360,8 @@ async function resolveStartOwnership(input) {
         identitySource: resolvedIdentity.source,
         identityWarning: resolvedIdentity.warning,
         suggestedActiveAgentId: resolvedIdentity.suggestedActiveAgentId,
+        laneClaimConfidence,
+        laneClaimSource,
     };
 }
 async function ensureChangeRequestReady(changeRequestId, ownerWorkIdentityId, resolvedDomain, scope) {
@@ -441,6 +460,14 @@ async function executeStartWorkSession(opts) {
     });
     const resolvedDomain = ownership.resolvedDomain;
     const activeAgentId = ownership.resolvedAgentId;
+    if (ownership.laneClaimConfidence === "low") {
+        throw (0, errors_1.catalogCliError)("START_LANE_CLAIM_LOW_CONFIDENCE");
+    }
+    if (ownership.laneClaimConfidence === "medium" && opts.confirmDomain !== true) {
+        throw (0, errors_1.catalogCliError)("START_LANE_CLAIM_CONFIRM_REQUIRED", {
+            what: `Lane claim is medium confidence (${ownership.laneClaimSource}) for domain "${resolvedDomain}".`,
+        });
+    }
     const explicitResume = opts.resume === true;
     const explicitCrId = opts.changeRequestId?.trim() || undefined;
     const existingCrId = explicitCrId ?? (explicitResume ? cfg.activeChangeRequestId?.trim() || undefined : undefined);
@@ -545,18 +572,31 @@ async function executeStartWorkSession(opts) {
     }
     (0, config_1.updateConfig)({ activeChangeRequestId: changeRequest.id });
     const output = [
-        "AgentBridge work started",
-        `Project: ${ctx.projectId}`,
-        `Change request: ${changeRequest.id}`,
-        `Work session: ${workSessionId}`,
-        "Scope:",
-        `- ${scope}`,
-        ...(activeAgentId ? [`Agent: ${activeAgentId}`] : []),
-        `Work Identity: ${ownership.ownerWorkIdentityId}`,
-        `Identity source: ${ownership.identitySource}`,
-        ...(resolvedDomain ? [`Domain: ${resolvedDomain}`] : []),
-        ...(ownership.identityWarning ? [`Warning:\n${ownership.identityWarning}`] : []),
-        "Next: supervision is now active.",
+        "AgentBridge start",
+        "",
+        "1) Actions performed",
+        `- Started tracked work for scope: ${scope}`,
+        `- Linked task ${changeRequest.id} to run ${workSessionId}`,
+        `- Work session: ${workSessionId}`,
+        ...(activeAgentId ? [`- Agent: ${activeAgentId}`] : []),
+        ...(resolvedDomain ? [`- Domain: ${resolvedDomain}`] : []),
+        "",
+        "2) Proof present / missing",
+        "- Present: task + run are active and linked",
+        "- Missing: verification proof for this change (tests/checks not recorded yet)",
+        `- Identity source: ${ownership.identitySource}`,
+        `- Lane claim confidence: ${ownership.laneClaimConfidence} (${ownership.laneClaimSource})`,
+        ...(ownership.identityWarning
+            ? [
+                "- Warning: identity config mismatch detected (using caller identity fallback)",
+                ownership.identityWarning,
+            ]
+            : []),
+        "",
+        "3) Next move",
+        "- Keep supervision running with `agentbridge watch`",
+        "- After changes, run `agentbridge verify -- <command>`",
+        "- Re-run `agentbridge watch` to confirm proof and boundaries",
     ];
     process.stdout.write(`${renderOtherSessions(output, [...new Set(otherSessionIds)]).join("\n")}\n`);
     return {
@@ -567,14 +607,31 @@ async function executeStartWorkSession(opts) {
     };
 }
 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;
+    return (0, session_state_1.isActiveLocalSession)((0, session_state_1.readSessionState)());
+}
+async function runLocalStart(intent) {
+    const validatedIntent = (0, intent_validation_1.validateIntent)(intent);
+    const existing = (0, session_state_1.readSessionState)();
+    if ((0, session_state_1.isActiveLocalSession)(existing)) {
+        if (existing.intent?.trim() === validatedIntent) {
+            process.stdout.write(`Contract already active: ${validatedIntent}\n`);
+            return existing;
+        }
+        throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED", {
+            what: "A different AgentBridge contract is already active.",
+            why: `Current contract: ${existing.intent ?? "(unknown)"}`,
+            next: "Finish the current contract in watch, or close it before starting a new one.",
+        });
+    }
+    const session = (0, session_1.openLocalSession)({
+        agentId: "local",
+        laneDomain: null,
+        intent: validatedIntent,
+        domains: [],
+        mode: "local_supervision",
+    });
+    process.stdout.write(`Contract created: ${validatedIntent}\n`);
+    return session;
 }
 async function runDefaultStart(opts = {}) {
     const { runLocalSupervision } = await Promise.resolve().then(() => __importStar(require("../local-supervision")));
@@ -595,6 +652,12 @@ function isStrictTrackedStartRequest(opts) {
     return explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
 }
 async function runStart(opts = {}) {
+    const cfg = (0, config_1.readConfig)();
+    const localIntent = opts.prompt?.trim() || opts.summary?.trim();
+    if (!cfg.projectId?.trim() && localIntent) {
+        await runLocalStart(localIntent);
+        return;
+    }
     const strictTrackedStart = isStrictTrackedStartRequest(opts);
     const explicitSummaryFlag = opts.summaryFlagProvided === true;
     const explicitScopeFlag = opts.scopeFlagProvided === true;