@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/auth/rbac.js

@@ -0,0 +1,26 @@
+/**
+ * Role-based access control for AgentDoctor surfaces.
+ * Not enterprise SSO — roles are applied after a verified identity (local session or OIDC JWT).
+ */
+export const RBAC_ROLE_RANK = {
+    viewer: 1,
+    developer: 2,
+    reviewer: 3,
+    "policy-admin": 4,
+    admin: 5,
+};
+const PERMISSION_MIN_ROLE = {
+    "read-findings": "viewer",
+    "read-audit": "viewer",
+    "export-reports": "developer",
+    "approve-actions": "reviewer",
+    "manage-policies": "policy-admin",
+    "admin-settings": "admin",
+};
+export function hasRbacPermission(role, permission) {
+    const required = PERMISSION_MIN_ROLE[permission];
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}
+export function roleAtLeast(role, required) {
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}

package/dist/cli/commands/architecture.d.ts

@@ -0,0 +1,6 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runArchitectureCommand(options: {
+    action: "init" | "analyze" | "check" | "explain";
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/architecture.js

@@ -0,0 +1,109 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { buildC4Views } from "../../architecture/c4.js";
+import { checkArchitectureAtRoot, explainArchitecture, initArchitecture, loadArchitectureContract, } from "../../architecture/contract.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runArchitectureCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "init": {
+                const written = await initArchitecture(root);
+                if (options.json)
+                    printJson({ path: written, createdOrExisting: true });
+                else
+                    process.stdout.write(`Architecture contract at ${written}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "analyze": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const views = buildC4Views(graph);
+                const loaded = await loadArchitectureContract(root);
+                const check = await checkArchitectureAtRoot(root, graph);
+                const payload = {
+                    c4: {
+                        levels: views.map((v) => v.level),
+                        views,
+                        label: "Inferred/proposed from graph evidence — not approved architecture facts",
+                    },
+                    contract: loaded
+                        ? {
+                            path: loaded.path,
+                            version: loaded.contract.version,
+                            layerCount: loaded.contract.layers.length,
+                            forbiddenCount: loaded.contract.forbidden.length,
+                            allowedCount: loaded.contract.allowed.length,
+                        }
+                        : null,
+                    check: {
+                        violations: check.violations.length,
+                        importEdgesChecked: check.importEdgesChecked,
+                        limitations: check.limitations,
+                    },
+                };
+                if (options.json)
+                    printJson(payload);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture analyze",
+                        `  C4 views: ${views.map((v) => v.level).join(", ")} (inferred)`,
+                        loaded
+                            ? `  contract: ${loaded.path} (layers=${loaded.contract.layers.length}, forbidden=${loaded.contract.forbidden.length})`
+                            : "  contract: none (run architecture init)",
+                        `  check violations: ${check.violations.length} (edges=${check.importEdgesChecked})`,
+                    ].join("\n") + "\n");
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "check": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json)
+                    printJson(check);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture check",
+                        `  contract: ${check.contractPath ?? "none"}`,
+                        `  import edges checked: ${check.importEdgesChecked}`,
+                        `  violations: ${check.violations.length}`,
+                        ...check.violations
+                            .slice(0, 30)
+                            .map((v) => `    - [${v.kind}] ${v.ruleId}: ${v.fromPath} → ${v.toPath} (${v.fromLayer}→${v.toLayer})`),
+                        ...check.limitations.map((l) => `  limitation: ${l}`),
+                    ].join("\n") + "\n");
+                }
+                if (check.violations.some((v) => v.kind === "forbidden")) {
+                    return EXIT_CODES.ISSUES_OR_THRESHOLD;
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "explain": {
+                const loaded = await loadArchitectureContract(root);
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json) {
+                    printJson({
+                        contract: loaded?.contract ?? null,
+                        path: loaded?.path ?? null,
+                        check,
+                        explanation: explainArchitecture(loaded?.contract ?? null, check),
+                    });
+                }
+                else {
+                    process.stdout.write(explainArchitecture(loaded?.contract ?? null, check));
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown architecture action`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/assurance.d.ts

@@ -0,0 +1,67 @@
+export declare function runChangeAnalyzeCommand(options: {
+    root: string;
+    since?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeVerifyCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeExplainCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeDiffCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeStatusCommand(options: {
+    root: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceInspectCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceVerifyCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofBuildCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofInspectCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExplainCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofVerifyCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExportCommand(options: {
+    root: string;
+    id: string;
+    out: string;
+    json?: boolean;
+}): Promise<number>;

package/dist/cli/commands/assurance.js

@@ -0,0 +1,210 @@
+import { analyzeChange, changeStatus, diffChange, explainChange, inspectEvidence, verifyChange, verifyEvidence, } from "../../assurance/change.js";
+import { buildProofFromEvidence, explainProof, exportProof, inspectProof, verifyProof, } from "../../assurance/proof.js";
+import { EXIT_CODES } from "../../types/index.js";
+function emit(json, value, human) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${human}\n`);
+    }
+}
+export async function runChangeAnalyzeCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), assessment, [
+            `Change assessment ${assessment.changeId}`,
+            `  files: ${assessment.changedFiles.length}`,
+            `  symbols: ${assessment.changedSymbols.length}`,
+            `  testImpact: ${assessment.testImpact.mode} (${assessment.testImpact.confidence})`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor change verify${options.since ? ` --since ${options.since}` : ""}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeVerifyCommand(options) {
+    try {
+        const { assessment, manifest } = await verifyChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), { assessment, manifest }, [
+            `Evidence produced for ${assessment.changeId}`,
+            `  directory: ${assessment.evidence.directory}`,
+            `  files: ${assessment.evidence.files?.join(", ") ?? ""}`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor evidence verify ${assessment.changeId}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeExplainCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        const text = explainChange(assessment);
+        emit(Boolean(options.json), { assessment, explanation: text }, text);
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeDiffCommand(options) {
+    try {
+        const diff = await diffChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), diff, [
+            `Change diff${diff.changeId ? ` (${diff.changeId})` : ""}`,
+            `  base → target: ${diff.baseRevision ?? "(wt)"} → ${diff.targetRevision ?? "?"}`,
+            `  files: +${diff.summary.added} ~${diff.summary.modified} -${diff.summary.deleted} ?${diff.summary.untracked}`,
+            diff.stat ? `\n${diff.stat}` : "  (no git --stat output)",
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeStatusCommand(options) {
+    try {
+        const status = await changeStatus({
+            root: options.root,
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), status, [
+            `Change status${status.changeId ? `: ${status.changeId}` : " (no evidence)"}`,
+            `  evidence: ${status.evidencePresent ? status.evidenceDirectory : "none"}`,
+            `  verificationStatus: ${status.verificationStatus}`,
+            `  proof: ${status.proofPresent ? status.proofId : "none"}`,
+            `  note: ${status.integrityNote}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runEvidenceInspectCommand(options) {
+    const result = await inspectEvidence({ root: options.root, changeId: options.changeId });
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "evidence not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Evidence ${options.changeId}`,
+        `  directory: ${result.directory}`,
+        `  files: ${result.presentFiles.join(", ")}`,
+        `  manifestStatus: ${result.manifest?.verificationStatus ?? "missing"}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runEvidenceVerifyCommand(options) {
+    const result = await verifyEvidence({ root: options.root, changeId: options.changeId });
+    emit(Boolean(options.json), result, [
+        `Evidence verify ${options.changeId}`,
+        `  status: ${result.verificationStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    if (!result.ok) {
+        return EXIT_CODES.ISSUES_OR_THRESHOLD;
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofBuildCommand(options) {
+    try {
+        const proof = await buildProofFromEvidence(options.root, options.changeId);
+        emit(Boolean(options.json), proof, [
+            `ChangeProof ${proof.proofId}`,
+            `  changeId: ${proof.changeId}`,
+            `  integrityStatus: ${proof.integrityStatus}`,
+            `  engineeringChecksStatus: ${proof.engineeringChecksStatus}`,
+            `  verificationState: ${proof.verificationState}`,
+            `  correctnessStatus: ${proof.correctnessStatus}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runProofInspectCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Proof ${result.proof.proofId}`,
+        `  changeId: ${result.proof.changeId}`,
+        `  integrityStatus: ${result.proof.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.proof.engineeringChecksStatus}`,
+        `  verificationState: ${result.proof.verificationState}`,
+        `  correctnessStatus: ${result.proof.correctnessStatus}`,
+        `  path: ${result.path}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofExplainCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    const text = explainProof(result.proof);
+    emit(Boolean(options.json), { proof: result.proof, explanation: text }, text);
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofVerifyCommand(options) {
+    const result = await verifyProof(options.root, options.id);
+    emit(Boolean(options.json), result, [
+        `Proof verify ${options.id}`,
+        `  integrityStatus: ${result.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.engineeringChecksStatus}`,
+        `  verificationState: ${result.verificationState}`,
+        `  correctnessStatus: ${result.correctnessStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    return result.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.ISSUES_OR_THRESHOLD;
+}
+export async function runProofExportCommand(options) {
+    const result = await exportProof(options.root, options.id, options.out);
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "export failed"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, `Exported proof to ${result.path}`);
+    return EXIT_CODES.SUCCESS;
+}

package/dist/cli/commands/brain.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runBrainCommand(options: {
+    action: string;
+    root?: string;
+    query?: string;
+    snapshotId?: string;
+    file?: string;
+    json?: boolean;
+    artifactId?: string;
+    decision?: "approved" | "rejected" | "pending-review" | "deprecated";
+    note?: string;
+}): Promise<ExitCode>;

package/dist/cli/commands/brain.js

@@ -0,0 +1,162 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { exportBrain, getBrainStatus, importBrain, initBrainStore, inspectBrainSummary, listBrainSnapshots, loadLatestBrain, rebuildBrain, searchBrain, showBrainSnapshot, } from "../../core/brain-cli/service.js";
+import { listProposals, reviewProposal, writeBrainProductSnapshot, } from "../../core/brain-product/init.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runBrainCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const json = options.json === true;
+    try {
+        switch (options.action) {
+            case "init": {
+                const status = await initBrainStore(root);
+                if (json)
+                    printJson(status);
+                else
+                    process.stdout.write(`Project Brain store ready at ${status.storeRoot}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "status": {
+                const status = await getBrainStatus(root);
+                if (json)
+                    printJson(status);
+                else
+                    process.stdout.write(`Brain status\n  root: ${status.root}\n  snapshots: ${status.snapshotCount}\n  latest: ${status.latestSnapshotId ?? "(none)"}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "inspect": {
+                const summary = await inspectBrainSummary(root);
+                if (json)
+                    printJson(summary);
+                else
+                    process.stdout.write(`Brain inspect\n  project: ${String(summary.projectName)}\n  snapshot: ${String(summary.snapshotId)}\n  claims: ${String(summary.claimCount)}\n  components: ${String(summary.componentCount)}\n  risks: ${String(summary.riskCount)}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "rebuild":
+            case "update": {
+                const brain = await rebuildBrain(root);
+                const productSnap = await writeBrainProductSnapshot(root);
+                if (json)
+                    printJson({
+                        snapshotId: brain.snapshot.id,
+                        projectName: brain.metadata.projectName,
+                        productSnapshot: productSnap,
+                    });
+                else
+                    process.stdout.write(`Rebuilt Project Brain snapshot ${brain.snapshot.id}\nRepository Brain product snapshot: ${productSnap}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot": {
+                const brain = await rebuildBrain(root);
+                const productSnap = await writeBrainProductSnapshot(root);
+                if (json)
+                    printJson({ brainSnapshotId: brain.snapshot.id, productSnapshot: productSnap });
+                else
+                    process.stdout.write(`Brain snapshot ${brain.snapshot.id}\nProduct snapshot ${productSnap}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "review": {
+                if (!options.artifactId || !options.decision) {
+                    console.error("Error: --artifact <id> and --decision <approved|rejected|...> required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const item = await reviewProposal({
+                    root,
+                    artifactId: options.artifactId,
+                    decision: options.decision,
+                    ...(options.note ? { note: options.note } : {}),
+                });
+                if (json)
+                    printJson(item);
+                else
+                    process.stdout.write(`Reviewed ${item.artifactId} -> ${item.status}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "proposals": {
+                const proposals = await listProposals(root);
+                if (json)
+                    printJson({ proposals });
+                else {
+                    for (const p of proposals) {
+                        process.stdout.write(`${p.id}  [${p.status}]  ${p.kind}  ${p.path}\n`);
+                    }
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot-list":
+            case "history": {
+                const snapshots = await listBrainSnapshots(root);
+                if (json)
+                    printJson({ snapshots });
+                else if (snapshots.length === 0) {
+                    process.stdout.write("No snapshots yet. Run: agentdoctor brain rebuild\n");
+                }
+                else {
+                    for (const snap of snapshots) {
+                        process.stdout.write(`${snap.id}  ${snap.createdAt}  ${snap.projectName}\n`);
+                    }
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "snapshot-show": {
+                if (!options.snapshotId) {
+                    console.error("Error: snapshot id required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const brain = await showBrainSnapshot(root, options.snapshotId);
+                printJson({
+                    snapshotId: brain.snapshot.id,
+                    projectName: brain.metadata.projectName,
+                    claimCount: brain.claims.length,
+                    componentCount: brain.components.length,
+                });
+                return EXIT_CODES.SUCCESS;
+            }
+            case "search": {
+                if (!options.query) {
+                    console.error("Error: search query required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                let brain = await loadLatestBrain(root);
+                if (!brain)
+                    brain = await rebuildBrain(root);
+                const hits = searchBrain(brain, options.query);
+                if (json)
+                    printJson({ query: options.query, hits });
+                else if (hits.length === 0)
+                    process.stdout.write("No matches.\n");
+                else
+                    for (const hit of hits)
+                        process.stdout.write(`[${hit.kind}] ${hit.id}: ${hit.text}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "export": {
+                if (!options.file) {
+                    console.error("Error: --file <path> required for export");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const out = await exportBrain(root, options.file, options.snapshotId);
+                process.stdout.write(`Exported redacted brain to ${out}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "import": {
+                if (!options.file) {
+                    console.error("Error: --file <path> required for import");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const meta = await importBrain(root, options.file);
+                process.stdout.write(`Imported snapshot ${meta.id}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown brain action: ${options.action}`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/complete.d.ts

@@ -0,0 +1,23 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runInitCommand(options: {
+    root?: string;
+    json?: boolean;
+    name?: string;
+    domain?: string;
+}): Promise<ExitCode>;
+export declare function runV2SurfaceCommand(options: {
+    action: string;
+    root?: string;
+    json?: boolean;
+    query?: string;
+    title?: string;
+    content?: string;
+    id?: string;
+    decision?: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    command?: string;
+    mode?: string;
+    symbol?: string;
+}): Promise<ExitCode>;